ce-workflow 0.4.0

package/dist/index.js

@@ -0,0 +1,4197 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/services/container.ts
+var ServiceContainer;
+var init_container = __esm({
+  "src/services/container.ts"() {
+    "use strict";
+    ServiceContainer = class {
+      factories = /* @__PURE__ */ new Map();
+      instances = /* @__PURE__ */ new Map();
+      register(key, factory) {
+        this.factories.set(key, factory);
+      }
+      get(key) {
+        const existing = this.instances.get(key);
+        if (existing !== void 0) return existing;
+        const factory = this.factories.get(key);
+        if (!factory) throw new Error(`Service not registered: ${key}`);
+        const instance = factory();
+        this.instances.set(key, instance);
+        return instance;
+      }
+      has(key) {
+        return this.factories.has(key);
+      }
+      // Typed accessors for core services
+      get config() {
+        return this.get("config");
+      }
+      get projects() {
+        return this.get("projects");
+      }
+      get rag() {
+        return this.get("rag");
+      }
+      get indexing() {
+        return this.get("indexing");
+      }
+      get tasks() {
+        return this.get("tasks");
+      }
+      get sessions() {
+        return this.get("sessions");
+      }
+      get prompts() {
+        return this.get("prompts");
+      }
+      get symbols() {
+        return this.get("symbols");
+      }
+      get dependencies() {
+        return this.get("dependencies");
+      }
+      get context() {
+        return this.get("context");
+      }
+      get logger() {
+        return this.get("logger");
+      }
+    };
+  }
+});
+
+// src/services/logger.ts
+import { EventEmitter } from "events";
+import * as fs from "fs";
+import * as path from "path";
+var Logger;
+var init_logger = __esm({
+  "src/services/logger.ts"() {
+    "use strict";
+    Logger = class extends EventEmitter {
+      logPath;
+      maxBytes = 2 * 1024 * 1024;
+      trimToBytes = 512 * 1024;
+      constructor(logPath) {
+        super();
+        this.logPath = logPath;
+      }
+      write(level, message, data) {
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        let logMessage = `[${timestamp}] [${level}] ${message}`;
+        if (data) {
+          if (data instanceof Error) {
+            logMessage += `
+${data.stack || data.message}`;
+          } else {
+            try {
+              logMessage += `
+${JSON.stringify(data, null, 2)}`;
+            } catch {
+              logMessage += `
+[Circular or invalid data]`;
+            }
+          }
+        }
+        logMessage += "\n";
+        this.emit("line", logMessage.trimEnd());
+        try {
+          const dir = path.dirname(this.logPath);
+          if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+          }
+          this.trimIfNeeded();
+          fs.appendFileSync(this.logPath, logMessage);
+        } catch (e) {
+          console.error(`[Logger Failure] Could not write to ${this.logPath}`, e);
+        }
+      }
+      trimIfNeeded() {
+        try {
+          if (!fs.existsSync(this.logPath)) return;
+          const stats = fs.statSync(this.logPath);
+          if (stats.size <= this.maxBytes) return;
+          const start = Math.max(0, stats.size - this.trimToBytes);
+          const fd = fs.openSync(this.logPath, "r");
+          const buffer = Buffer.alloc(stats.size - start);
+          fs.readSync(fd, buffer, 0, buffer.length, start);
+          fs.closeSync(fd);
+          const header = `[${(/* @__PURE__ */ new Date()).toISOString()}] [INFO] Log truncated to last ${this.trimToBytes} bytes
+`;
+          fs.writeFileSync(this.logPath, header + buffer.toString("utf-8"));
+        } catch {
+        }
+      }
+      info(message, data) {
+        this.write("INFO", message, data);
+      }
+      error(message, error) {
+        this.write("ERROR", message, error);
+      }
+      warn(message, data) {
+        this.write("WARN", message, data);
+      }
+      debug(message, data) {
+        this.write("DEBUG", message, data);
+      }
+      getLogPath() {
+        return this.logPath;
+      }
+    };
+  }
+});
+
+// src/types/config.ts
+var DEFAULT_MCP_CONFIG, DEFAULT_PERMISSIONS;
+var init_config = __esm({
+  "src/types/config.ts"() {
+    "use strict";
+    DEFAULT_MCP_CONFIG = {
+      server: {
+        port: 3e3,
+        autoStart: false
+      },
+      projects: [],
+      defaults: {
+        includeNew: false,
+        permissions: {
+          knowledge: true,
+          tasks: true,
+          refs: true
+        },
+        semanticSearch: {
+          enabled: true,
+          model: "Xenova/all-MiniLM-L6-v2"
+        }
+      }
+    };
+    DEFAULT_PERMISSIONS = {
+      knowledge: true,
+      tasks: true,
+      refs: true
+    };
+  }
+});
+
+// src/lib/paths.ts
+var paths_exports = {};
+__export(paths_exports, {
+  detectWorkspaceRoot: () => detectWorkspaceRoot,
+  ensureDir: () => ensureDir,
+  getAgentCoreDir: () => getAgentCoreDir,
+  getConfigPath: () => getConfigPath,
+  getDataPath: () => getDataPath,
+  getHome: () => getHome,
+  getKnowledgePath: () => getKnowledgePath,
+  getLogPath: () => getLogPath,
+  getPreferencesPath: () => getPreferencesPath,
+  getRefsPath: () => getRefsPath,
+  getTasksPath: () => getTasksPath,
+  getWorkspaceName: () => getWorkspaceName
+});
+import * as fs2 from "fs";
+import * as path2 from "path";
+function getHome() {
+  return process.env.CE_WORKFLOW_HOME || path2.join(process.env.HOME || "~", ".ce-workflow");
+}
+function getConfigPath() {
+  return path2.join(getHome(), "config.yaml");
+}
+function getLogPath() {
+  return path2.join(getHome(), "mcp-server.log");
+}
+function getDataPath(projectName) {
+  return path2.join(getHome(), "workspaces", projectName);
+}
+function getKnowledgePath(projectName) {
+  return path2.join(getDataPath(projectName), "knowledge");
+}
+function getTasksPath(projectName) {
+  return path2.join(getDataPath(projectName), "tasks");
+}
+function getRefsPath(projectName) {
+  return path2.join(getDataPath(projectName), "refs");
+}
+function getPreferencesPath() {
+  return path2.join(getHome(), "preferences.json");
+}
+function ensureDir(dirPath) {
+  if (!fs2.existsSync(dirPath)) {
+    fs2.mkdirSync(dirPath, { recursive: true });
+  }
+}
+function detectWorkspaceRoot() {
+  const envOverride = process.env.CE_WORKFLOW_WORKSPACE;
+  if (envOverride) return envOverride;
+  let current = process.cwd();
+  while (current !== "/") {
+    if (fs2.existsSync(path2.join(current, ".git"))) {
+      return current;
+    }
+    current = path2.dirname(current);
+  }
+  return process.cwd();
+}
+function getWorkspaceName(workspaceRoot) {
+  return path2.basename(workspaceRoot);
+}
+function getAgentCoreDir() {
+  const packageRoot = path2.resolve(import.meta.dirname, "..", "..");
+  return path2.join(packageRoot, "agent-core");
+}
+var init_paths = __esm({
+  "src/lib/paths.ts"() {
+    "use strict";
+  }
+});
+
+// src/services/config-service.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import YAML from "yaml";
+var ConfigService;
+var init_config_service = __esm({
+  "src/services/config-service.ts"() {
+    "use strict";
+    init_config();
+    init_paths();
+    ConfigService = class extends EventEmitter2 {
+      cache = null;
+      cacheTime = 0;
+      TTL = 5e3;
+      load() {
+        const now = Date.now();
+        if (this.cache && now - this.cacheTime < this.TTL) {
+          return this.cache;
+        }
+        this.cache = this.loadFromDisk();
+        this.cacheTime = now;
+        return this.cache;
+      }
+      save(config) {
+        const oldConfig = this.cache;
+        this.saveToDisk(config);
+        this.cache = config;
+        this.cacheTime = Date.now();
+        this.emit("change", oldConfig || this.loadFromDisk(), config);
+      }
+      invalidate() {
+        this.cache = null;
+      }
+      isCacheValid() {
+        return this.cache !== null && Date.now() - this.cacheTime < this.TTL;
+      }
+      getConfigFilePath() {
+        return getConfigPath();
+      }
+      // --- Config mutation helpers ---
+      setProject(config, name, expose, permissions, projectPath, semanticSearch) {
+        const existing = this.findProject(config, { name, path: projectPath });
+        if (existing) {
+          existing.expose = expose;
+          if (projectPath && !existing.path) existing.path = projectPath;
+          if (permissions) existing.permissions = { ...existing.permissions, ...permissions };
+          if (semanticSearch) existing.semanticSearch = semanticSearch;
+        } else {
+          config.projects.push({
+            name,
+            path: projectPath,
+            expose,
+            permissions: permissions ? { ...DEFAULT_PERMISSIONS, ...permissions } : { ...DEFAULT_PERMISSIONS },
+            semanticSearch
+          });
+        }
+        return config;
+      }
+      removeProject(config, name) {
+        config.projects = config.projects.filter((p) => p.name !== name);
+        return config;
+      }
+      isProjectExposed(config, name, projectPath) {
+        const project = this.findProject(config, { name, path: projectPath });
+        return project ? project.expose : config.defaults.includeNew;
+      }
+      getProjectPermissions(config, name, projectPath) {
+        const project = this.findProject(config, { name, path: projectPath });
+        return project?.permissions ?? config.defaults.permissions;
+      }
+      findProject(config, identifier) {
+        const targetPath = identifier.path ? this.normalizePath(identifier.path) : void 0;
+        return config.projects.find((p) => {
+          const configPath = p.path ? this.normalizePath(p.path) : void 0;
+          if (targetPath && configPath) return configPath === targetPath;
+          if (!targetPath && !configPath && identifier.name) return p.name === identifier.name;
+          if (targetPath && !configPath && identifier.name) return p.name === identifier.name;
+          return false;
+        });
+      }
+      cleanStaleProjects(config) {
+        const removed = [];
+        config.projects = config.projects.filter((project) => {
+          const exists = project.path ? fs3.existsSync(project.path) : true;
+          if (!exists) removed.push(project.name);
+          return exists;
+        });
+        return { config, removed };
+      }
+      // --- Private ---
+      normalizePath(p) {
+        let normalized = p;
+        while (normalized.length > 1 && (normalized.endsWith("/") || normalized.endsWith("\\"))) {
+          normalized = normalized.slice(0, -1);
+        }
+        return normalized;
+      }
+      loadFromDisk() {
+        const configPath = getConfigPath();
+        if (!fs3.existsSync(configPath)) return { ...DEFAULT_MCP_CONFIG };
+        try {
+          const content = fs3.readFileSync(configPath, "utf-8");
+          return this.parseConfig(content);
+        } catch {
+          return { ...DEFAULT_MCP_CONFIG };
+        }
+      }
+      saveToDisk(config) {
+        const configPath = getConfigPath();
+        ensureDir(path3.dirname(configPath));
+        const header = `# CE-Workflow MCP Hub Configuration
+# Manages which projects are exposed via MCP
+
+`;
+        const content = header + YAML.stringify(config, { indent: 2, lineWidth: 0 });
+        fs3.writeFileSync(configPath, content);
+      }
+      parseConfig(content) {
+        try {
+          const parsed = YAML.parse(content);
+          return {
+            server: {
+              port: parsed?.server?.port ?? DEFAULT_MCP_CONFIG.server.port,
+              autoStart: parsed?.server?.autoStart ?? DEFAULT_MCP_CONFIG.server.autoStart
+            },
+            defaults: {
+              includeNew: parsed?.defaults?.includeNew ?? DEFAULT_MCP_CONFIG.defaults.includeNew,
+              permissions: {
+                knowledge: parsed?.defaults?.permissions?.knowledge ?? DEFAULT_PERMISSIONS.knowledge,
+                tasks: parsed?.defaults?.permissions?.tasks ?? DEFAULT_PERMISSIONS.tasks,
+                refs: parsed?.defaults?.permissions?.refs ?? DEFAULT_PERMISSIONS.refs
+              },
+              semanticSearch: parsed?.defaults?.semanticSearch ?? DEFAULT_MCP_CONFIG.defaults.semanticSearch
+            },
+            projects: Array.isArray(parsed?.projects) ? parsed.projects.map((p) => ({
+              name: p.name || "",
+              path: p.path,
+              expose: p.expose ?? true,
+              permissions: {
+                knowledge: p.permissions?.knowledge ?? DEFAULT_PERMISSIONS.knowledge,
+                tasks: p.permissions?.tasks ?? DEFAULT_PERMISSIONS.tasks,
+                refs: p.permissions?.refs ?? DEFAULT_PERMISSIONS.refs
+              },
+              semanticSearch: p.semanticSearch,
+              last_synced_version: p.last_synced_version
+            })) : [],
+            last_synced_version: parsed?.last_synced_version
+          };
+        } catch {
+          return { ...DEFAULT_MCP_CONFIG };
+        }
+      }
+    };
+  }
+});
+
+// src/lib/detection.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+function scanForProjects(options = {}) {
+  const { excludeWorkspace, knownProjects } = options;
+  const projects = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  if (knownProjects && knownProjects.length > 0) {
+    for (const p of knownProjects) {
+      try {
+        if (!p.path || !fs4.existsSync(p.path)) continue;
+        if (p.name === excludeWorkspace) continue;
+        const dataPath = getDataPath(p.name);
+        if (seenPaths.has(dataPath)) continue;
+        seenPaths.add(dataPath);
+        const knowledgePath = path4.join(dataPath, "knowledge");
+        const refsPath = path4.join(dataPath, "refs");
+        const tasksPath = path4.join(dataPath, "tasks");
+        projects.push({
+          name: p.name,
+          path: p.path,
+          sourcePath: p.path,
+          dataPath,
+          source: "global",
+          knowledgePath: fs4.existsSync(knowledgePath) ? knowledgePath : void 0,
+          refsPath: fs4.existsSync(refsPath) ? refsPath : void 0,
+          tasksPath: fs4.existsSync(tasksPath) ? tasksPath : void 0,
+          semanticSearchEnabled: true
+        });
+      } catch {
+      }
+    }
+  }
+  const workspacesDir = path4.join(getHome(), "workspaces");
+  if (fs4.existsSync(workspacesDir)) {
+    try {
+      const entries = fs4.readdirSync(workspacesDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name === excludeWorkspace) continue;
+        const dataPath = path4.join(workspacesDir, entry.name);
+        if (seenPaths.has(dataPath)) continue;
+        seenPaths.add(dataPath);
+        const knowledgePath = path4.join(dataPath, "knowledge");
+        const refsPath = path4.join(dataPath, "refs");
+        const tasksPath = path4.join(dataPath, "tasks");
+        const configPath = path4.join(dataPath, "config.yaml");
+        let sourcePath;
+        if (fs4.existsSync(configPath)) {
+          try {
+            const content = fs4.readFileSync(configPath, "utf-8");
+            const match = content.match(/sourcePath:\s*["']?([^"'\n\r]+)["']?/);
+            sourcePath = match?.[1]?.trim();
+          } catch {
+          }
+        }
+        projects.push({
+          name: entry.name,
+          path: sourcePath || dataPath,
+          sourcePath,
+          dataPath,
+          source: "global",
+          knowledgePath: fs4.existsSync(knowledgePath) ? knowledgePath : void 0,
+          refsPath: fs4.existsSync(refsPath) ? refsPath : void 0,
+          tasksPath: fs4.existsSync(tasksPath) ? tasksPath : void 0,
+          semanticSearchEnabled: true
+        });
+      }
+    } catch {
+    }
+  }
+  return projects;
+}
+function findClosestProject(projects, cwd = process.cwd()) {
+  const matches = projects.map((p) => {
+    let matchPath = "";
+    if (cwd === p.path) matchPath = p.path;
+    else if (p.sourcePath && cwd === p.sourcePath) matchPath = p.sourcePath;
+    else if (cwd.startsWith(p.path + "/")) matchPath = p.path;
+    else if (p.sourcePath && cwd.startsWith(p.sourcePath + "/")) matchPath = p.sourcePath;
+    return { project: p, matchPath };
+  }).filter((m) => m.matchPath !== "");
+  matches.sort((a, b) => b.matchPath.length - a.matchPath.length);
+  return matches[0]?.project;
+}
+var init_detection = __esm({
+  "src/lib/detection.ts"() {
+    "use strict";
+    init_paths();
+  }
+});
+
+// src/services/project-service.ts
+var ProjectService;
+var init_project_service = __esm({
+  "src/services/project-service.ts"() {
+    "use strict";
+    init_detection();
+    ProjectService = class {
+      cache = null;
+      cacheTime = 0;
+      TTL = 3e4;
+      lastOptions = null;
+      scan(options) {
+        const now = Date.now();
+        const optionsMatch = JSON.stringify(options) === JSON.stringify(this.lastOptions);
+        if (this.cache && optionsMatch && now - this.cacheTime < this.TTL) {
+          return this.cache;
+        }
+        this.cache = scanForProjects(options);
+        this.cacheTime = now;
+        this.lastOptions = options ?? null;
+        return this.cache;
+      }
+      refresh(options) {
+        this.invalidate();
+        return this.scan(options);
+      }
+      invalidate() {
+        this.cache = null;
+        this.lastOptions = null;
+      }
+      getCached() {
+        if (this.cache && Date.now() - this.cacheTime < this.TTL) {
+          return this.cache;
+        }
+        return null;
+      }
+      findClosest(cwd) {
+        const projects = this.getCached() ?? this.scan();
+        return findClosestProject(projects, cwd);
+      }
+    };
+  }
+});
+
+// src/services/rag-service.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+var INDEX_VERSION, DEFAULT_MODEL, BATCH_SIZE, RAGService;
+var init_rag_service = __esm({
+  "src/services/rag-service.ts"() {
+    "use strict";
+    INDEX_VERSION = "1.0.0";
+    DEFAULT_MODEL = "Xenova/all-MiniLM-L6-v2";
+    BATCH_SIZE = 16;
+    RAGService = class _RAGService {
+      static pipelineInstance = null;
+      static activeModelName = null;
+      static loadPromise = null;
+      logger;
+      modelName;
+      constructor(logger, modelName = DEFAULT_MODEL) {
+        this.logger = logger;
+        this.modelName = modelName;
+      }
+      // --- Pipeline ---
+      async getPipeline() {
+        if (_RAGService.activeModelName === this.modelName && _RAGService.pipelineInstance) {
+          return _RAGService.pipelineInstance;
+        }
+        if (_RAGService.activeModelName === this.modelName && _RAGService.loadPromise) {
+          return _RAGService.loadPromise;
+        }
+        this.logger.info(`[RAG] Initializing model ${this.modelName}...`);
+        _RAGService.activeModelName = this.modelName;
+        _RAGService.loadPromise = (async () => {
+          try {
+            const { pipeline } = await import("@xenova/transformers");
+            const pipe = await pipeline("feature-extraction", this.modelName);
+            _RAGService.pipelineInstance = pipe;
+            this.logger.info(`[RAG] Model ${this.modelName} initialized.`);
+            return pipe;
+          } catch (error) {
+            _RAGService.pipelineInstance = null;
+            _RAGService.activeModelName = null;
+            _RAGService.loadPromise = null;
+            this.logger.error(`[RAG] Failed to initialize model ${this.modelName}`, error);
+            throw error;
+          }
+        })();
+        return _RAGService.loadPromise;
+      }
+      // --- Batch Embedding (key improvement) ---
+      async generateEmbedding(text) {
+        const pipe = await this.getPipeline();
+        const output = await pipe(text, { pooling: "mean", normalize: true });
+        return Array.from(output.data);
+      }
+      async generateEmbeddings(texts) {
+        if (texts.length === 0) return [];
+        if (texts.length === 1) return [await this.generateEmbedding(texts[0])];
+        const pipe = await this.getPipeline();
+        const results = [];
+        for (let i = 0; i < texts.length; i += BATCH_SIZE) {
+          const batch = texts.slice(i, i + BATCH_SIZE);
+          const batchResults = await Promise.all(
+            batch.map(async (text) => {
+              const output = await pipe(text, { pooling: "mean", normalize: true });
+              return Array.from(output.data);
+            })
+          );
+          results.push(...batchResults);
+        }
+        return results;
+      }
+      // --- Index Management ---
+      loadIndex(indexPath) {
+        if (fs5.existsSync(indexPath)) {
+          try {
+            return JSON.parse(fs5.readFileSync(indexPath, "utf-8"));
+          } catch {
+          }
+        }
+        return { version: INDEX_VERSION, baseModel: this.modelName, chunks: [] };
+      }
+      saveIndex(indexPath, index) {
+        const dir = path5.dirname(indexPath);
+        if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+        const tmpPath = `${indexPath}.tmp`;
+        fs5.writeFileSync(tmpPath, JSON.stringify(index, null, 2));
+        fs5.renameSync(tmpPath, indexPath);
+      }
+      // --- Incremental Indexing ---
+      async indexFile(indexPath, filePath, content, mtime) {
+        const index = this.loadIndex(indexPath);
+        if (!index.fileMetadata) index.fileMetadata = {};
+        if (mtime !== void 0 && index.fileMetadata[filePath]?.mtime === mtime) {
+          return false;
+        }
+        index.chunks = index.chunks.filter((c) => c.filePath !== filePath);
+        const textChunks = this.chunkContent(content);
+        const embeddings = await this.generateEmbeddings(textChunks);
+        for (let i = 0; i < textChunks.length; i++) {
+          index.chunks.push({
+            id: `${filePath}-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
+            filePath,
+            content: textChunks[i],
+            embedding: embeddings[i],
+            mtime
+          });
+        }
+        index.fileMetadata[filePath] = { mtime: mtime ?? Date.now(), chunkCount: textChunks.length };
+        this.saveIndex(indexPath, index);
+        return true;
+      }
+      async indexCodeFile(indexPath, filePath, chunks, mtime) {
+        const index = this.loadIndex(indexPath);
+        if (!index.fileMetadata) index.fileMetadata = {};
+        if (index.fileMetadata[filePath]?.mtime === mtime) return;
+        index.chunks = index.chunks.filter((c) => c.filePath !== filePath);
+        const texts = chunks.map((c) => c.content);
+        const embeddings = await this.generateEmbeddings(texts);
+        for (let i = 0; i < chunks.length; i++) {
+          const chunk = chunks[i];
+          index.chunks.push({
+            id: `${filePath}-${chunk.lineStart}-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
+            filePath,
+            content: chunk.content,
+            embedding: embeddings[i],
+            mtime,
+            lineStart: chunk.lineStart,
+            lineEnd: chunk.lineEnd,
+            context: chunk.context,
+            language: chunk.language
+          });
+        }
+        index.fileMetadata[filePath] = { mtime, chunkCount: chunks.length };
+        this.saveIndex(indexPath, index);
+      }
+      // --- Batch Indexing (load once, save once) ---
+      async indexFileBatch(index, filePath, content, mtime) {
+        if (!index.fileMetadata) index.fileMetadata = {};
+        if (mtime !== void 0 && index.fileMetadata[filePath]?.mtime === mtime) {
+          return false;
+        }
+        index.chunks = index.chunks.filter((c) => c.filePath !== filePath);
+        const textChunks = this.chunkContent(content);
+        const embeddings = await this.generateEmbeddings(textChunks);
+        for (let i = 0; i < textChunks.length; i++) {
+          index.chunks.push({
+            id: `${filePath}-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
+            filePath,
+            content: textChunks[i],
+            embedding: embeddings[i],
+            mtime
+          });
+        }
+        index.fileMetadata[filePath] = { mtime: mtime ?? Date.now(), chunkCount: textChunks.length };
+        return true;
+      }
+      async indexCodeFileBatch(index, filePath, chunks, mtime) {
+        if (!index.fileMetadata) index.fileMetadata = {};
+        if (index.fileMetadata[filePath]?.mtime === mtime) return false;
+        index.chunks = index.chunks.filter((c) => c.filePath !== filePath);
+        const texts = chunks.map((c) => c.content);
+        const embeddings = await this.generateEmbeddings(texts);
+        for (let i = 0; i < chunks.length; i++) {
+          const chunk = chunks[i];
+          index.chunks.push({
+            id: `${filePath}-${chunk.lineStart}-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
+            filePath,
+            content: chunk.content,
+            embedding: embeddings[i],
+            mtime,
+            lineStart: chunk.lineStart,
+            lineEnd: chunk.lineEnd,
+            context: chunk.context,
+            language: chunk.language
+          });
+        }
+        index.fileMetadata[filePath] = { mtime, chunkCount: chunks.length };
+        return true;
+      }
+      removeFileBatch(index, filePath) {
+        index.chunks = index.chunks.filter((c) => c.filePath !== filePath);
+        if (index.fileMetadata) delete index.fileMetadata[filePath];
+      }
+      removeFile(indexPath, filePath) {
+        const index = this.loadIndex(indexPath);
+        index.chunks = index.chunks.filter((c) => c.filePath !== filePath);
+        if (index.fileMetadata) delete index.fileMetadata[filePath];
+        this.saveIndex(indexPath, index);
+      }
+      needsReindex(indexPath, filePath, mtime) {
+        const index = this.loadIndex(indexPath);
+        return index.fileMetadata?.[filePath]?.mtime !== mtime;
+      }
+      // --- Search ---
+      async search(indexPath, query, limit = 5, minScore = 0) {
+        const index = this.loadIndex(indexPath);
+        if (index.chunks.length === 0) return [];
+        const queryEmbedding = await this.generateEmbedding(query);
+        const scored = index.chunks.map((chunk) => ({
+          ...chunk,
+          score: this.cosineSimilarity(queryEmbedding, chunk.embedding)
+        }));
+        scored.sort((a, b) => b.score - a.score);
+        return scored.filter((r) => r.score >= minScore).slice(0, limit);
+      }
+      // --- Stats ---
+      getStats(indexPath) {
+        const index = this.loadIndex(indexPath);
+        return {
+          totalChunks: index.chunks.length,
+          totalFiles: index.fileMetadata ? Object.keys(index.fileMetadata).length : 0,
+          lastFullIndex: index.lastFullIndex
+        };
+      }
+      getIndexedFiles(indexPath) {
+        const index = this.loadIndex(indexPath);
+        return index.fileMetadata ? Object.keys(index.fileMetadata) : [];
+      }
+      // --- Symbol-Aware Chunking ---
+      chunkCodeBySymbols(content, filePath, symbolService, maxChunkSize = 1500) {
+        const result = symbolService.extract(content, filePath);
+        const lines = content.split("\n");
+        if (result.symbols.length === 0) {
+          return this.chunkContentWithLines(content, maxChunkSize);
+        }
+        const sorted = [...result.symbols].sort((a, b) => a.line - b.line);
+        const chunks = [];
+        let lastEnd = 0;
+        for (const sym of sorted) {
+          const symStart = sym.line - 1;
+          const symEnd = (sym.endLine ?? sym.line) - 1;
+          if (symStart > lastEnd) {
+            const gapContent = lines.slice(lastEnd, symStart).join("\n").trim();
+            if (gapContent.length > 50) {
+              chunks.push({ content: gapContent, lineStart: lastEnd + 1, lineEnd: symStart });
+            }
+          }
+          const symContent = lines.slice(symStart, symEnd + 1).join("\n");
+          if (symContent.length <= maxChunkSize) {
+            chunks.push({ content: symContent, lineStart: sym.line, lineEnd: sym.endLine ?? sym.line });
+          } else {
+            const subChunks = this.chunkContentWithLines(symContent, maxChunkSize, 100);
+            for (const sc of subChunks) {
+              chunks.push({
+                content: sc.content,
+                lineStart: symStart + sc.lineStart,
+                lineEnd: symStart + sc.lineEnd
+              });
+            }
+          }
+          lastEnd = symEnd + 1;
+        }
+        if (lastEnd < lines.length) {
+          const trailContent = lines.slice(lastEnd).join("\n").trim();
+          if (trailContent.length > 50) {
+            chunks.push({ content: trailContent, lineStart: lastEnd + 1, lineEnd: lines.length });
+          }
+        }
+        return chunks;
+      }
+      // --- Helpers ---
+      cosineSimilarity(a, b) {
+        let dot = 0, normA = 0, normB = 0;
+        for (let i = 0; i < a.length; i++) {
+          const av = a[i] ?? 0, bv = b[i] ?? 0;
+          dot += av * bv;
+          normA += av * av;
+          normB += bv * bv;
+        }
+        return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+      }
+      chunkContent(content, maxChunkSize = 1e3, overlap = 100) {
+        const chunks = [];
+        let start = 0;
+        while (start < content.length) {
+          let end = start + maxChunkSize;
+          if (end >= content.length) {
+            end = content.length;
+          } else {
+            const lastNewline = content.lastIndexOf("\n", end);
+            if (lastNewline > start + maxChunkSize / 2) end = lastNewline;
+          }
+          const chunk = content.substring(start, end).trim();
+          if (chunk.length > 50) chunks.push(chunk);
+          if (end === content.length) break;
+          start = end - overlap;
+        }
+        return chunks;
+      }
+      chunkContentWithLines(content, maxChunkSize = 1e3, overlap = 100) {
+        const chunks = [];
+        const lines = content.split("\n");
+        let currentChunk = "";
+        let chunkStartLine = 1;
+        let currentLine = 1;
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i] ?? "";
+          const potential = currentChunk + (currentChunk ? "\n" : "") + line;
+          if (potential.length > maxChunkSize && currentChunk.length > 0) {
+            if (currentChunk.trim().length > 50) {
+              chunks.push({ content: currentChunk.trim(), lineStart: chunkStartLine, lineEnd: currentLine - 1 });
+            }
+            const overlapLines = [];
+            let overlapSize = 0;
+            for (let j = i - 1; j >= 0 && overlapSize < overlap; j--) {
+              const prev = lines[j] ?? "";
+              overlapLines.unshift(prev);
+              overlapSize += prev.length + 1;
+            }
+            currentChunk = overlapLines.join("\n") + (overlapLines.length > 0 ? "\n" : "") + line;
+            chunkStartLine = currentLine - overlapLines.length;
+          } else {
+            currentChunk = potential;
+          }
+          currentLine++;
+        }
+        if (currentChunk.trim().length > 50) {
+          chunks.push({ content: currentChunk.trim(), lineStart: chunkStartLine, lineEnd: lines.length });
+        }
+        return chunks;
+      }
+    };
+  }
+});
+
+// src/services/indexing-service.ts
+import { EventEmitter as EventEmitter3 } from "events";
+var IndexingService;
+var init_indexing_service = __esm({
+  "src/services/indexing-service.ts"() {
+    "use strict";
+    IndexingService = class extends EventEmitter3 {
+      constructor(rag, logger) {
+        super();
+        this.rag = rag;
+        this.logger = logger;
+      }
+      jobs = /* @__PURE__ */ new Map();
+      getProgress(project) {
+        const job = this.jobs.get(project);
+        if (job) return { ...job.progress };
+        return { project, state: "idle", itemsDone: 0 };
+      }
+      isRunning(project) {
+        return this.getProgress(project).state === "running";
+      }
+      update(project, patch) {
+        const existing = this.jobs.get(project);
+        const next = {
+          ...existing?.progress ?? this.getProgress(project),
+          ...patch,
+          project
+        };
+        this.jobs.set(project, { ...existing ?? { progress: next }, progress: next });
+        this.emit("progress", next);
+      }
+      startOrStatus(project, runner) {
+        const current = this.jobs.get(project);
+        if (current?.progress.state === "running" && current.promise) {
+          return { status: "already_running", progress: { ...current.progress } };
+        }
+        const initial = {
+          project,
+          state: "running",
+          startedAt: Date.now(),
+          itemsDone: 0
+        };
+        const job = { progress: initial, promise: void 0 };
+        this.jobs.set(project, job);
+        this.emit("progress", initial);
+        job.promise = (async () => {
+          try {
+            await runner();
+            this.update(project, { state: "complete", completedAt: Date.now(), currentItem: void 0 });
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.logger.error(`[Indexing] Job failed for '${project}'`, err);
+            this.update(project, { state: "failed", completedAt: Date.now(), lastError: msg });
+          }
+        })();
+        return { status: "started", progress: { ...initial } };
+      }
+    };
+  }
+});
+
+// src/services/task-service.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+var TaskService;
+var init_task_service = __esm({
+  "src/services/task-service.ts"() {
+    "use strict";
+    init_paths();
+    TaskService = class {
+      list(projectName) {
+        const tasksDir = getTasksPath(projectName);
+        if (!fs6.existsSync(tasksDir)) return [];
+        const tasks = [];
+        try {
+          for (const entry of fs6.readdirSync(tasksDir, { withFileTypes: true })) {
+            if (!entry.isDirectory()) continue;
+            const metaPath = path6.join(tasksDir, entry.name, "meta.json");
+            if (fs6.existsSync(metaPath)) {
+              try {
+                const meta = JSON.parse(fs6.readFileSync(metaPath, "utf-8"));
+                tasks.push({ task_slug: entry.name, ...meta });
+              } catch {
+              }
+            }
+          }
+        } catch {
+        }
+        return tasks;
+      }
+      get(projectName, taskSlug) {
+        const metaPath = path6.join(getTasksPath(projectName), taskSlug, "meta.json");
+        if (!fs6.existsSync(metaPath)) return null;
+        try {
+          const meta = JSON.parse(fs6.readFileSync(metaPath, "utf-8"));
+          return { task_slug: taskSlug, ...meta };
+        } catch {
+          return null;
+        }
+      }
+      create(projectName, taskSlug, data) {
+        const taskDir = path6.join(getTasksPath(projectName), taskSlug);
+        ensureDir(taskDir);
+        const meta = {
+          task_slug: taskSlug,
+          title: data.title || taskSlug,
+          summary: data.summary || "",
+          status: "draft",
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          updated_at: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        fs6.writeFileSync(path6.join(taskDir, "meta.json"), JSON.stringify(meta, null, 2));
+        return meta;
+      }
+      update(projectName, taskSlug, updates) {
+        const metaPath = path6.join(getTasksPath(projectName), taskSlug, "meta.json");
+        if (!fs6.existsSync(metaPath)) return null;
+        try {
+          const meta = JSON.parse(fs6.readFileSync(metaPath, "utf-8"));
+          const updated = { ...meta, ...updates, updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+          fs6.writeFileSync(metaPath, JSON.stringify(updated, null, 2));
+          return { task_slug: taskSlug, ...updated };
+        } catch {
+          return null;
+        }
+      }
+      delete(projectName, taskSlug) {
+        const taskDir = path6.join(getTasksPath(projectName), taskSlug);
+        if (!fs6.existsSync(taskDir)) return false;
+        try {
+          fs6.rmSync(taskDir, { recursive: true, force: true });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      search(projectName, options) {
+        let tasks = this.list(projectName);
+        const { keyword, status, agent, since, limit = 20 } = options;
+        if (keyword) {
+          const kw = keyword.toLowerCase();
+          tasks = tasks.filter(
+            (t) => t.title.toLowerCase().includes(kw) || t.summary.toLowerCase().includes(kw)
+          );
+        }
+        if (status) tasks = tasks.filter((t) => t.status === status);
+        if (agent) tasks = tasks.filter((t) => t.agent === agent);
+        if (since) {
+          const sinceDate = new Date(since).getTime();
+          tasks = tasks.filter((t) => {
+            const updated = t.updated_at ? new Date(t.updated_at).getTime() : 0;
+            return updated >= sinceDate;
+          });
+        }
+        return tasks.slice(0, limit);
+      }
+      validatePhase(projectName, taskSlug, phase) {
+        const task = this.get(projectName, taskSlug);
+        if (!task) return { valid: false, missing: ["Task not found"], suggestions: [] };
+        const missing = [];
+        const suggestions = [];
+        if (phase === "planning" && !task.status?.includes("research")) {
+          missing.push("Research phase not completed");
+          suggestions.push("Complete research first");
+        }
+        if (phase === "execution" && !task.status?.includes("plan")) {
+          missing.push("Planning phase not completed");
+          suggestions.push("Complete planning first");
+        }
+        return { valid: missing.length === 0, missing, suggestions };
+      }
+    };
+  }
+});
+
+// src/services/session-service.ts
+import * as fs7 from "fs";
+import * as path7 from "path";
+var SessionService;
+var init_session_service = __esm({
+  "src/services/session-service.ts"() {
+    "use strict";
+    init_paths();
+    SessionService = class {
+      start(projectName, taskSlug, agent, phase) {
+        const taskDir = path7.join(getTasksPath(projectName), taskSlug);
+        ensureDir(taskDir);
+        const session = {
+          task_slug: taskSlug,
+          agent,
+          phase,
+          started_at: (/* @__PURE__ */ new Date()).toISOString(),
+          status: "active"
+        };
+        const sessionPath = path7.join(taskDir, "session.json");
+        fs7.writeFileSync(sessionPath, JSON.stringify(session, null, 2));
+        return { success: true, message: `Session started: ${agent}/${phase} on ${taskSlug}` };
+      }
+      end(projectName, taskSlug) {
+        const sessionPath = path7.join(getTasksPath(projectName), taskSlug, "session.json");
+        if (!fs7.existsSync(sessionPath)) {
+          return { success: false, message: `No active session for ${taskSlug}` };
+        }
+        try {
+          const session = JSON.parse(fs7.readFileSync(sessionPath, "utf-8"));
+          session.ended_at = (/* @__PURE__ */ new Date()).toISOString();
+          session.status = "completed";
+          fs7.writeFileSync(sessionPath, JSON.stringify(session, null, 2));
+          return { success: true, message: `Session ended for ${taskSlug}` };
+        } catch {
+          return { success: false, message: `Failed to end session for ${taskSlug}` };
+        }
+      }
+      getSession(projectName, taskSlug) {
+        const sessionPath = path7.join(getTasksPath(projectName), taskSlug, "session.json");
+        if (!fs7.existsSync(sessionPath)) return null;
+        try {
+          return JSON.parse(fs7.readFileSync(sessionPath, "utf-8"));
+        } catch {
+          return null;
+        }
+      }
+      updateTodos(projectName, taskSlug, phase, agent, items) {
+        const taskDir = path7.join(getTasksPath(projectName), taskSlug);
+        ensureDir(taskDir);
+        const todos = {
+          phase,
+          agent,
+          items,
+          updated_at: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const todosPath = path7.join(taskDir, "agent-todos.json");
+        fs7.writeFileSync(todosPath, JSON.stringify(todos, null, 2));
+        return { success: true, message: `Updated ${items.length} todos for ${taskSlug}` };
+      }
+      getTodos(projectName, taskSlug) {
+        const todosPath = path7.join(getTasksPath(projectName), taskSlug, "agent-todos.json");
+        if (!fs7.existsSync(todosPath)) return null;
+        try {
+          return JSON.parse(fs7.readFileSync(todosPath, "utf-8"));
+        } catch {
+          return null;
+        }
+      }
+    };
+  }
+});
+
+// src/services/prompt-service.ts
+import * as fs8 from "fs";
+import * as path8 from "path";
+var PromptService;
+var init_prompt_service = __esm({
+  "src/services/prompt-service.ts"() {
+    "use strict";
+    init_paths();
+    PromptService = class {
+      baseProtocolCache = null;
+      getAllPrompts() {
+        const promptsDir = path8.join(getAgentCoreDir(), "prompts");
+        if (!fs8.existsSync(promptsDir)) return [];
+        const prompts = [];
+        try {
+          for (const file of fs8.readdirSync(promptsDir)) {
+            if (!file.endsWith(".md") || file.startsWith("_")) continue;
+            const filePath = path8.join(promptsDir, file);
+            const parsed = this.parsePromptFile(filePath);
+            if (parsed) prompts.push(parsed);
+          }
+        } catch {
+        }
+        return prompts;
+      }
+      getPrompt(name) {
+        const all = this.getAllPrompts();
+        const search = name.toLowerCase();
+        return all.find(
+          (p) => p.name === name || p.id === name || p.name.toLowerCase() === search || p.id.toLowerCase() === search
+        );
+      }
+      renderPrompt(content, args) {
+        let rendered = content;
+        for (const [key, val] of Object.entries(args)) {
+          rendered = rendered.replace(new RegExp(`{{${key}}}`, "g"), val);
+        }
+        return rendered;
+      }
+      renderWithContext(content, args, context) {
+        const renderArgs = { ...args };
+        if (!renderArgs["CE_DATA"]) renderArgs["CE_DATA"] = context.dataPath;
+        if (!renderArgs["CE_HOME"]) renderArgs["CE_HOME"] = context.home;
+        if (!renderArgs["WORKSPACE_ROOT"]) renderArgs["WORKSPACE_ROOT"] = context.workspaceRoot;
+        if (!renderArgs["WORKSPACE_NAME"]) renderArgs["WORKSPACE_NAME"] = context.workspaceName;
+        const agentContent = this.renderPrompt(content, renderArgs);
+        const base = this.loadBaseProtocol();
+        const rendered = base ? `${base}
+${agentContent}` : agentContent;
+        return {
+          rendered,
+          context: {
+            CE_DATA: renderArgs["CE_DATA"],
+            CE_HOME: renderArgs["CE_HOME"],
+            WORKSPACE_ROOT: renderArgs["WORKSPACE_ROOT"],
+            WORKSPACE_NAME: renderArgs["WORKSPACE_NAME"]
+          }
+        };
+      }
+      loadBaseProtocol() {
+        if (this.baseProtocolCache !== null) return this.baseProtocolCache;
+        const basePath = path8.join(getAgentCoreDir(), "prompts", "_base.md");
+        if (fs8.existsSync(basePath)) {
+          const content = fs8.readFileSync(basePath, "utf-8");
+          this.baseProtocolCache = content.replace(/^---[\s\S]*?---\n*/, "");
+          return this.baseProtocolCache;
+        }
+        this.baseProtocolCache = "";
+        return "";
+      }
+      parsePromptFile(filePath) {
+        try {
+          const raw = fs8.readFileSync(filePath, "utf-8");
+          const fmMatch = raw.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+          if (!fmMatch) return null;
+          const fmText = fmMatch[1];
+          const content = raw.slice(fmMatch[0].length);
+          const id = path8.basename(filePath, ".md");
+          const nameMatch = fmText.match(/name:\s*(.+)/);
+          const descMatch = fmText.match(/description:\s*(.+)/);
+          if (!nameMatch || !descMatch) return null;
+          const args = [];
+          const reqSection = fmText.match(/required-args:\s*\n((?:\s+-[\s\S]*?)(?=\n\w|\n$|$))/);
+          if (reqSection) {
+            const items = reqSection[1].match(/- name:\s*(\w+)/g);
+            items?.forEach((item) => {
+              const name = item.match(/- name:\s*(\w+)/)?.[1];
+              if (name) args.push({ name, description: name, required: true });
+            });
+          }
+          const optSection = fmText.match(/optional-args:\s*\n((?:\s+-[\s\S]*?)(?=\n\w|\n$|$))/);
+          if (optSection) {
+            const items = optSection[1].match(/- name:\s*(\w+)/g);
+            items?.forEach((item) => {
+              const name = item.match(/- name:\s*(\w+)/)?.[1];
+              if (name) args.push({ name, description: name, required: false });
+            });
+          }
+          return {
+            id,
+            name: nameMatch[1].trim(),
+            description: descMatch[1].trim(),
+            arguments: args,
+            content
+          };
+        } catch {
+          return null;
+        }
+      }
+    };
+  }
+});
+
+// src/services/symbol-service.ts
+var SymbolService;
+var init_symbol_service = __esm({
+  "src/services/symbol-service.ts"() {
+    "use strict";
+    SymbolService = class {
+      extract(content, filePath) {
+        const lines = content.split("\n");
+        const symbols = [];
+        const exports = [];
+        const imports = [];
+        const language = this.getLanguage(filePath);
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i] ?? "";
+          const lineNum = i + 1;
+          const trimmed = line.trim();
+          if (trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*") || !trimmed) continue;
+          const importMatch = line.match(/^import\s+(?:\{([^}]+)\}|(\w+))\s+from\s+['"]([^'"]+)['"]/);
+          if (importMatch) {
+            imports.push(importMatch[3] ?? "");
+            continue;
+          }
+          const reExportMatch = line.match(/^export\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/);
+          if (reExportMatch) {
+            const items = (reExportMatch[1] ?? "").split(",").map((s) => s.trim().split(" as ")[0]?.trim() ?? "");
+            exports.push(...items.filter(Boolean));
+            continue;
+          }
+          const isExported = trimmed.startsWith("export ");
+          const cleanLine = isExported ? trimmed.replace(/^export\s+(default\s+)?/, "") : trimmed;
+          const funcMatch = cleanLine.match(/^(?:async\s+)?function\s+(\w+)\s*(\([^)]*\))/);
+          if (funcMatch?.[1]) {
+            const endLine = this.findBlockEnd(lines, i);
+            symbols.push({ name: funcMatch[1], type: "function", line: lineNum, endLine, signature: `function ${funcMatch[1]}${funcMatch[2] ?? "()"}`, exported: isExported });
+            if (isExported) exports.push(funcMatch[1]);
+            continue;
+          }
+          const arrowMatch = cleanLine.match(/^(const|let|var)\s+(\w+)\s*(?::\s*[^=]+)?\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/);
+          if (arrowMatch?.[2]) {
+            const endLine = this.findBlockEnd(lines, i);
+            symbols.push({ name: arrowMatch[2], type: "function", line: lineNum, endLine, signature: `const ${arrowMatch[2]} = (...)`, exported: isExported });
+            if (isExported) exports.push(arrowMatch[2]);
+            continue;
+          }
+          const classMatch = cleanLine.match(/^(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?/);
+          if (classMatch?.[1]) {
+            let sig = `class ${classMatch[1]}`;
+            if (classMatch[2]) sig += ` extends ${classMatch[2]}`;
+            const endLine = this.findBlockEnd(lines, i);
+            symbols.push({ name: classMatch[1], type: "class", line: lineNum, endLine, signature: sig, exported: isExported });
+            if (isExported) exports.push(classMatch[1]);
+            continue;
+          }
+          const ifaceMatch = cleanLine.match(/^interface\s+(\w+)/);
+          if (ifaceMatch?.[1]) {
+            const endLine = this.findBlockEnd(lines, i);
+            symbols.push({ name: ifaceMatch[1], type: "interface", line: lineNum, endLine, signature: `interface ${ifaceMatch[1]}`, exported: isExported });
+            if (isExported) exports.push(ifaceMatch[1]);
+            continue;
+          }
+          const typeMatch = cleanLine.match(/^type\s+(\w+)(?:<[^>]+>)?\s*=/);
+          if (typeMatch?.[1]) {
+            symbols.push({ name: typeMatch[1], type: "type", line: lineNum, signature: `type ${typeMatch[1]}`, exported: isExported });
+            if (isExported) exports.push(typeMatch[1]);
+            continue;
+          }
+          const enumMatch = cleanLine.match(/^(?:const\s+)?enum\s+(\w+)/);
+          if (enumMatch?.[1]) {
+            const endLine = this.findBlockEnd(lines, i);
+            symbols.push({ name: enumMatch[1], type: "enum", line: lineNum, endLine, signature: `enum ${enumMatch[1]}`, exported: isExported });
+            if (isExported) exports.push(enumMatch[1]);
+            continue;
+          }
+          const varMatch = cleanLine.match(/^(const|let|var)\s+(\w+)\s*(?::\s*([^=]+))?\s*=/);
+          if (varMatch?.[2] && !line.includes("=>")) {
+            symbols.push({ name: varMatch[2], type: varMatch[1] === "const" ? "const" : "variable", line: lineNum, signature: `${varMatch[1]} ${varMatch[2]}`, exported: isExported });
+            if (isExported) exports.push(varMatch[2]);
+            continue;
+          }
+        }
+        return { filePath, language, symbols, exports: [...new Set(exports)], imports: [...new Set(imports)] };
+      }
+      /**
+       * Find the end of a brace-delimited block starting from the given line index.
+       * Returns 1-based line number of the closing brace.
+       */
+      findBlockEnd(lines, startIdx) {
+        let depth = 0;
+        let foundOpen = false;
+        for (let i = startIdx; i < lines.length; i++) {
+          const line = lines[i] ?? "";
+          for (const ch of line) {
+            if (ch === "{") {
+              depth++;
+              foundOpen = true;
+            } else if (ch === "}") {
+              depth--;
+            }
+            if (foundOpen && depth === 0) return i + 1;
+          }
+        }
+        return startIdx + 1;
+      }
+      search(results, query, options = {}) {
+        const { type = "any", fuzzy = true, limit = 10, minScore = 0.3 } = options;
+        const matches = [];
+        for (const result of results) {
+          for (const symbol of result.symbols) {
+            if (type !== "any" && symbol.type !== type) continue;
+            const score = fuzzy ? this.fuzzyScore(query, symbol.name) : symbol.name.toLowerCase().includes(query.toLowerCase()) ? 1 : 0;
+            if (score >= minScore) matches.push({ ...symbol, file: result.filePath, score });
+          }
+        }
+        matches.sort((a, b) => b.score !== a.score ? b.score - a.score : a.name.length - b.name.length);
+        return matches.slice(0, limit);
+      }
+      fuzzyScore(query, name) {
+        const q = query.toLowerCase(), s = name.toLowerCase();
+        if (q === s) return 1;
+        if (s.startsWith(q)) return 0.9;
+        if (s.includes(q)) return 0.7;
+        if (q.startsWith(s)) return 0.6;
+        const dist = this.levenshtein(q, s);
+        return Math.max(0, (1 - dist / Math.max(q.length, s.length)) * 0.5);
+      }
+      levenshtein(a, b) {
+        const m = [];
+        for (let i = 0; i <= b.length; i++) m[i] = [i];
+        for (let j = 0; j <= a.length; j++) m[0][j] = j;
+        for (let i = 1; i <= b.length; i++) {
+          for (let j = 1; j <= a.length; j++) {
+            m[i][j] = b[i - 1] === a[j - 1] ? m[i - 1][j - 1] : Math.min(m[i - 1][j - 1] + 1, m[i][j - 1] + 1, m[i - 1][j] + 1);
+          }
+        }
+        return m[b.length][a.length];
+      }
+      getLanguage(filePath) {
+        const ext = filePath.toLowerCase().split(".").pop() ?? "";
+        const map = {
+          ts: "typescript",
+          tsx: "typescript",
+          js: "javascript",
+          jsx: "javascript",
+          mjs: "javascript",
+          cjs: "javascript",
+          py: "python",
+          go: "go",
+          rs: "rust",
+          java: "java",
+          kt: "kotlin",
+          rb: "ruby",
+          php: "php",
+          swift: "swift",
+          c: "c",
+          cpp: "cpp",
+          h: "c",
+          hpp: "cpp",
+          cs: "csharp"
+        };
+        return map[ext] ?? "unknown";
+      }
+    };
+  }
+});
+
+// src/lib/gitignore.ts
+import * as fs9 from "fs";
+import * as path9 from "path";
+import ignore from "ignore";
+function loadGitignore(root) {
+  const ig = ignore();
+  const gitignorePath = path9.join(root, ".gitignore");
+  if (fs9.existsSync(gitignorePath)) {
+    try {
+      const content = fs9.readFileSync(gitignorePath, "utf-8");
+      ig.add(content);
+    } catch {
+    }
+  }
+  ig.add(["node_modules", ".git", "dist", "build", ".next", "__pycache__", "venv", ".venv", "target", "vendor", "coverage"]);
+  return ig;
+}
+var init_gitignore = __esm({
+  "src/lib/gitignore.ts"() {
+    "use strict";
+  }
+});
+
+// src/services/dependency-service.ts
+import * as fs10 from "fs";
+import * as path10 from "path";
+var IMPORT_PATTERNS, DependencyService;
+var init_dependency_service = __esm({
+  "src/services/dependency-service.ts"() {
+    "use strict";
+    init_gitignore();
+    IMPORT_PATTERNS = {
+      typescript: [
+        /import\s+(?:(?:[\w*{}\s,]+)\s+from\s+)?['"]([^'"]+)['"]/g,
+        /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+        /export\s+(?:\*|{[^}]*})\s+from\s+['"]([^'"]+)['"]/g,
+        /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g
+      ],
+      javascript: [
+        /import\s+(?:(?:[\w*{}\s,]+)\s+from\s+)?['"]([^'"]+)['"]/g,
+        /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+        /export\s+(?:\*|{[^}]*})\s+from\s+['"]([^'"]+)['"]/g,
+        /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g
+      ],
+      python: [/from\s+([\w.]+)\s+import/g, /^import\s+([\w.]+)/gm],
+      go: [/import\s+(?:\w+\s+)?["']([^"']+)["']/g, /^\s*["']([^"']+)["']\s*$/gm],
+      rust: [/use\s+([\w:]+)/g, /mod\s+(\w+)/g, /extern\s+crate\s+(\w+)/g],
+      java: [/import\s+([\w.]+)/g]
+    };
+    DependencyService = class {
+      parseImports(filePath, content) {
+        const ext = path10.extname(filePath).toLowerCase().replace(/^\./, "");
+        const language = this.getLanguage(ext);
+        const patterns = IMPORT_PATTERNS[language] || IMPORT_PATTERNS.javascript || [];
+        const edges = [];
+        for (const pattern of patterns) {
+          pattern.lastIndex = 0;
+          let match;
+          while ((match = pattern.exec(content)) !== null) {
+            const importPath = match[1];
+            if (!importPath) continue;
+            let importType = "static";
+            if (pattern.source.includes("import\\s*\\(")) importType = "dynamic";
+            else if (pattern.source.includes("export")) importType = "re-export";
+            const resolved = this.resolveImport(filePath, importPath, language);
+            edges.push({ source: filePath, target: resolved.path, importType, importPath, isResolved: resolved.isResolved });
+          }
+        }
+        return edges;
+      }
+      buildGraph(files) {
+        const graph = { edges: [], files: /* @__PURE__ */ new Set(), lastUpdated: Date.now() };
+        for (const file of files) {
+          graph.files.add(file.path);
+          graph.edges.push(...this.parseImports(file.path, file.content));
+        }
+        return graph;
+      }
+      findRelated(filePath, graph, options = {}) {
+        const { includeImports = true, includeImportedBy = true, depth = 1 } = options;
+        const results = [];
+        const visited = /* @__PURE__ */ new Set();
+        const traverse = (file, d) => {
+          if (d > depth || visited.has(file)) return;
+          visited.add(file);
+          if (includeImports) {
+            for (const e of graph.edges.filter((e2) => e2.source === file && e2.isResolved)) {
+              if (!visited.has(e.target)) {
+                results.push({ file: e.target, relationship: "imports", importPath: e.importPath });
+                if (d < depth) traverse(e.target, d + 1);
+              }
+            }
+          }
+          if (includeImportedBy) {
+            for (const e of graph.edges.filter((e2) => e2.target === file && e2.isResolved)) {
+              if (!visited.has(e.source)) {
+                results.push({ file: e.source, relationship: "imported-by", importPath: e.importPath });
+                if (d < depth) traverse(e.source, d + 1);
+              }
+            }
+          }
+        };
+        traverse(filePath, 1);
+        return results;
+      }
+      async scanProject(projectRoot, options = {}) {
+        const {
+          extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs", ".java"]
+        } = options;
+        const ig = loadGitignore(projectRoot);
+        const files = [];
+        const scan = (dir) => {
+          try {
+            for (const entry of fs10.readdirSync(dir, { withFileTypes: true })) {
+              const full = path10.join(dir, entry.name);
+              const rel = path10.relative(projectRoot, full);
+              if (ig.ignores(rel)) continue;
+              if (entry.isDirectory()) {
+                scan(full);
+              } else if (extensions.includes(path10.extname(entry.name).toLowerCase())) {
+                try {
+                  files.push({ path: full, content: fs10.readFileSync(full, "utf-8") });
+                } catch {
+                }
+              }
+            }
+          } catch {
+          }
+        };
+        scan(projectRoot);
+        return this.buildGraph(files);
+      }
+      resolveImport(fromFile, importPath, language) {
+        if (importPath.startsWith(".")) {
+          const fromDir = path10.dirname(fromFile);
+          const base = path10.resolve(fromDir, importPath);
+          for (const c of this.candidates(base, language)) {
+            if (fs10.existsSync(c)) return { path: c, isResolved: true };
+          }
+          return { path: base, isResolved: false };
+        }
+        return { path: importPath, isResolved: false };
+      }
+      candidates(base, language) {
+        const cs = [];
+        if (path10.extname(base)) cs.push(base);
+        switch (language) {
+          case "typescript":
+            cs.push(`${base}.ts`, `${base}.tsx`, `${base}/index.ts`, `${base}/index.tsx`, `${base}.js`, `${base}/index.js`);
+            break;
+          case "javascript":
+            cs.push(`${base}.js`, `${base}.jsx`, `${base}/index.js`, `${base}.mjs`, `${base}.cjs`);
+            break;
+          case "python":
+            cs.push(`${base}.py`, `${base}/__init__.py`);
+            break;
+          case "go":
+            cs.push(`${base}.go`);
+            break;
+          case "rust":
+            cs.push(`${base}.rs`, `${base}/mod.rs`);
+            break;
+          case "java":
+            cs.push(`${base}.java`);
+            break;
+          default:
+            cs.push(base);
+        }
+        return cs;
+      }
+      getLanguage(ext) {
+        const map = {
+          ts: "typescript",
+          tsx: "typescript",
+          js: "javascript",
+          jsx: "javascript",
+          mjs: "javascript",
+          cjs: "javascript",
+          py: "python",
+          go: "go",
+          rs: "rust",
+          java: "java"
+        };
+        return map[ext] ?? "javascript";
+      }
+    };
+  }
+});
+
+// src/services/context-service.ts
+var ContextService;
+var init_context_service = __esm({
+  "src/services/context-service.ts"() {
+    "use strict";
+    ContextService = class {
+      constructor(container) {
+        this.container = container;
+      }
+      getLanguageFromExtension(ext) {
+        const e = ext.toLowerCase().replace(/^\./, "");
+        const map = {
+          ts: "typescript",
+          tsx: "typescript",
+          mts: "typescript",
+          cts: "typescript",
+          js: "javascript",
+          jsx: "javascript",
+          mjs: "javascript",
+          cjs: "javascript",
+          py: "python",
+          pyw: "python",
+          go: "go",
+          rs: "rust",
+          java: "java",
+          kt: "java",
+          kts: "java"
+        };
+        return map[e] ?? "unknown";
+      }
+      extractContext(content, lineStart, language) {
+        if (language === "unknown") return void 0;
+        try {
+          const lines = content.split("\n");
+          const ctx = this.findEnclosing(lines, lineStart - 1, language);
+          return ctx ? this.formatContext(ctx) : void 0;
+        } catch {
+          return void 0;
+        }
+      }
+      extractAllContexts(content, language) {
+        const contexts = /* @__PURE__ */ new Map();
+        if (language === "unknown") return contexts;
+        const lines = content.split("\n");
+        const patterns = this.getPatterns(language);
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i] ?? "";
+          for (const p of patterns) {
+            const m = line.match(p.regex);
+            if (m) {
+              const name = m[1] ?? m[2] ?? "unknown";
+              contexts.set(i + 1, { type: p.type, name, line: i + 1 });
+              break;
+            }
+          }
+        }
+        return contexts;
+      }
+      findEnclosing(lines, targetIdx, language) {
+        const patterns = this.getPatterns(language);
+        let braceDepth = 0;
+        for (let i = targetIdx; i >= 0; i--) {
+          const line = lines[i] ?? "";
+          if (language !== "python") {
+            braceDepth += this.countChar(line, "}") - this.countChar(line, "{");
+          }
+          for (const p of patterns) {
+            const m = line.match(p.regex);
+            if (m) {
+              const name = m[1] ?? m[2] ?? "unknown";
+              if (language === "python") {
+                const targetIndent = this.getIndent(lines[targetIdx] ?? "");
+                if (this.getIndent(line) < targetIndent) return { type: p.type, name, line: i + 1 };
+              } else if (braceDepth >= 0) {
+                return { type: p.type, name, line: i + 1 };
+              }
+            }
+          }
+        }
+        return void 0;
+      }
+      getPatterns(lang) {
+        switch (lang) {
+          case "typescript":
+          case "javascript":
+            return [
+              { regex: /^\s*(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/, type: "class" },
+              { regex: /^\s*(?:export\s+)?interface\s+(\w+)/, type: "interface" },
+              { regex: /^\s*(?:export\s+)?type\s+(\w+)/, type: "type" },
+              { regex: /^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/, type: "function" },
+              { regex: /^\s*(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:function|\([^)]*\)\s*=>|\w+\s*=>)/, type: "const" },
+              { regex: /^\s*(?:async\s+)?(?:static\s+)?(?:get\s+|set\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*\w+)?\s*\{?/, type: "method" }
+            ];
+          case "python":
+            return [
+              { regex: /^(\s*)class\s+(\w+)/, type: "class" },
+              { regex: /^(\s*)(?:async\s+)?def\s+(\w+)/, type: "function" }
+            ];
+          case "go":
+            return [
+              { regex: /^func\s+(?:\([^)]+\)\s+)?(\w+)/, type: "function" },
+              { regex: /^type\s+(\w+)\s+(?:struct|interface)/, type: "type" }
+            ];
+          case "rust":
+            return [
+              { regex: /^\s*(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/, type: "function" },
+              { regex: /^\s*impl(?:<[^>]+>)?\s+(\w+)/, type: "class" },
+              { regex: /^\s*(?:pub\s+)?struct\s+(\w+)/, type: "type" }
+            ];
+          case "java":
+            return [
+              { regex: /^\s*(?:public|private|protected)?\s*(?:static\s+)?class\s+(\w+)/, type: "class" },
+              { regex: /^\s*(?:public|private|protected)?\s*interface\s+(\w+)/, type: "interface" }
+            ];
+          default:
+            return [];
+        }
+      }
+      formatContext(m) {
+        switch (m.type) {
+          case "class":
+            return `class ${m.name}`;
+          case "interface":
+            return `interface ${m.name}`;
+          case "type":
+            return `type ${m.name}`;
+          case "function":
+            return `function ${m.name}()`;
+          case "method":
+            return `${m.name}()`;
+          case "const":
+            return `const ${m.name}`;
+        }
+      }
+      countChar(str, char) {
+        let c = 0;
+        for (let i = 0; i < str.length; i++) if (str[i] === char) c++;
+        return c;
+      }
+      getIndent(line) {
+        const m = line.match(/^(\s*)/);
+        let level = 0;
+        for (const ch of m?.[1] ?? "") level += ch === "	" ? 4 : 1;
+        return level;
+      }
+    };
+  }
+});
+
+// src/services/index.ts
+function createServices() {
+  const container = new ServiceContainer();
+  container.register("logger", () => new Logger(getLogPath()));
+  container.register("config", () => new ConfigService());
+  container.register("projects", () => new ProjectService());
+  container.register("rag", () => new RAGService(container.logger));
+  container.register("indexing", () => new IndexingService(container.rag, container.logger));
+  container.register("tasks", () => new TaskService());
+  container.register("sessions", () => new SessionService());
+  container.register("prompts", () => new PromptService());
+  container.register("symbols", () => new SymbolService());
+  container.register("dependencies", () => new DependencyService());
+  container.register("context", () => new ContextService(container));
+  return container;
+}
+var init_services = __esm({
+  "src/services/index.ts"() {
+    "use strict";
+    init_container();
+    init_logger();
+    init_config_service();
+    init_project_service();
+    init_rag_service();
+    init_indexing_service();
+    init_task_service();
+    init_session_service();
+    init_prompt_service();
+    init_symbol_service();
+    init_dependency_service();
+    init_context_service();
+    init_paths();
+    init_container();
+    init_logger();
+    init_config_service();
+    init_project_service();
+    init_rag_service();
+    init_indexing_service();
+    init_task_service();
+    init_session_service();
+    init_prompt_service();
+    init_symbol_service();
+    init_dependency_service();
+    init_context_service();
+  }
+});
+
+// src/mcp/registry.ts
+import "zod";
+var ToolRegistry;
+var init_registry = __esm({
+  "src/mcp/registry.ts"() {
+    "use strict";
+    ToolRegistry = class {
+      tools = /* @__PURE__ */ new Map();
+      handlers = /* @__PURE__ */ new Map();
+      schemas = /* @__PURE__ */ new Map();
+      register(def, handler, schema) {
+        this.tools.set(def.name, def);
+        this.handlers.set(def.name, handler);
+        if (schema) this.schemas.set(def.name, schema);
+      }
+      registerMany(registrations) {
+        for (const reg of registrations) {
+          this.register(reg.definition, reg.handler, reg.schema);
+        }
+      }
+      async dispatch(name, args) {
+        const handler = this.handlers.get(name);
+        if (!handler) {
+          return {
+            content: [{ type: "text", text: `Unknown tool: ${name}` }],
+            isError: true
+          };
+        }
+        const schema = this.schemas.get(name);
+        if (schema) {
+          const result = schema.safeParse(args);
+          if (!result.success) {
+            return {
+              content: [{ type: "text", text: `Invalid arguments for ${name}: ${result.error.message}` }],
+              isError: true
+            };
+          }
+        }
+        return handler(args);
+      }
+      listTools() {
+        return Array.from(this.tools.values());
+      }
+      has(name) {
+        return this.tools.has(name);
+      }
+    };
+  }
+});
+
+// src/mcp/tools/project.ts
+import { z as z2 } from "zod";
+function createProjectTools(container) {
+  return [
+    {
+      definition: {
+        name: "resolve_path",
+        description: "Resolve configuration paths for a project.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Name of the project" },
+            path: { type: "string", description: "Absolute path to the project root" }
+          }
+        }
+      },
+      schema: ResolvePathSchema,
+      handler: async (args) => {
+        const { project, path: projectPath } = args;
+        const { getDataPath: getDataPath3, getHome: getHome2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+        const name = project || "unknown";
+        const result = {
+          project: name,
+          dataPath: getDataPath3(name),
+          home: getHome2(),
+          sourcePath: projectPath
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    },
+    {
+      definition: {
+        name: "list_projects",
+        description: "List all projects exposed via MCP.",
+        inputSchema: { type: "object", properties: {} }
+      },
+      handler: async () => {
+        const config = container.config.load();
+        const projects = container.projects.scan({
+          knownProjects: config.projects.filter((p) => !!p.path).map((p) => ({ name: p.name, path: p.path }))
+        });
+        const exposed = projects.filter((p) => container.config.isProjectExposed(config, p.name, p.sourcePath || p.path));
+        const list = exposed.map((p) => ({ name: p.name, source: p.source, path: p.path }));
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(list, null, 2) + "\n\nTip: Use these project names for project-specific tools."
+          }]
+        };
+      }
+    },
+    {
+      definition: {
+        name: "get_project_context",
+        description: "Get the project context/architecture for a specific project.",
+        inputSchema: {
+          type: "object",
+          properties: { project: { type: "string", description: "Name of the project" } },
+          required: ["project"]
+        }
+      },
+      schema: GetProjectContextSchema,
+      handler: async (args) => {
+        const { project } = args;
+        const { getKnowledgePath: getKnowledgePath2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+        const fs16 = await import("fs");
+        const path15 = await import("path");
+        const knowledgeDir = getKnowledgePath2(project);
+        const contextFile = path15.join(knowledgeDir, "context.md");
+        if (!fs16.existsSync(contextFile)) {
+          return { content: [{ type: "text", text: `No project context found for "${project}".` }], isError: true };
+        }
+        const content = fs16.readFileSync(contextFile, "utf-8");
+        return { content: [{ type: "text", text: content }] };
+      }
+    },
+    {
+      definition: {
+        name: "index_knowledge",
+        description: "Update the semantic search index for a specific project.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Name of the project" },
+            force: { type: "boolean", description: "Force re-indexing" },
+            clean: { type: "boolean", description: "Wipe index and rebuild" }
+          },
+          required: ["project"]
+        }
+      },
+      schema: IndexKnowledgeSchema,
+      handler: async (args) => {
+        const { project, force, clean } = args;
+        const { getKnowledgePath: getKnowledgePath2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+        const fs16 = await import("fs");
+        const path15 = await import("path");
+        const knowledgeDir = getKnowledgePath2(project);
+        if (!fs16.existsSync(knowledgeDir)) {
+          return { content: [{ type: "text", text: `No knowledge directory for "${project}".` }], isError: true };
+        }
+        const indexPath = path15.join(knowledgeDir, "embeddings.json");
+        if (clean && fs16.existsSync(indexPath)) fs16.unlinkSync(indexPath);
+        const index = container.rag.loadIndex(indexPath);
+        const files = fs16.readdirSync(knowledgeDir).filter((f) => f.endsWith(".md"));
+        let indexed = 0;
+        for (const file of files) {
+          const filePath = path15.join(knowledgeDir, file);
+          const content = fs16.readFileSync(filePath, "utf-8");
+          const mtime = force ? void 0 : fs16.statSync(filePath).mtimeMs;
+          const didIndex = await container.rag.indexFileBatch(index, filePath, content, mtime);
+          if (didIndex) indexed++;
+        }
+        if (indexed > 0) container.rag.saveIndex(indexPath, index);
+        return {
+          content: [{ type: "text", text: JSON.stringify({ project, indexed, total: files.length, indexPath }, null, 2) }]
+        };
+      }
+    },
+    {
+      definition: {
+        name: "reload_config",
+        description: "Reload MCP configuration from disk.",
+        inputSchema: { type: "object", properties: {} }
+      },
+      handler: async () => {
+        container.config.invalidate();
+        const config = container.config.load();
+        return {
+          content: [{
+            type: "text",
+            text: `Config reloaded. ${config.projects.length} projects configured.`
+          }]
+        };
+      }
+    }
+  ];
+}
+var ResolvePathSchema, GetProjectContextSchema, IndexKnowledgeSchema;
+var init_project = __esm({
+  "src/mcp/tools/project.ts"() {
+    "use strict";
+    ResolvePathSchema = z2.object({
+      project: z2.string().optional(),
+      path: z2.string().optional()
+    });
+    GetProjectContextSchema = z2.object({
+      project: z2.string()
+    });
+    IndexKnowledgeSchema = z2.object({
+      project: z2.string(),
+      force: z2.boolean().optional(),
+      clean: z2.boolean().optional()
+    });
+  }
+});
+
+// src/mcp/tools/search.ts
+import { z as z3 } from "zod";
+import * as fs11 from "fs";
+import * as path11 from "path";
+function createSearchTools(container) {
+  return [
+    {
+      definition: {
+        name: "search_knowledge",
+        description: "Search across project knowledge bases. Returns results with relevance scores.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Search query" },
+            project: { type: "string", description: "Optional: limit to specific project" },
+            max_tokens: { type: "number", description: "Optional: max tokens for response" },
+            min_score: { type: "number", description: "Optional: min relevance score (0-1)" }
+          },
+          required: ["query"]
+        }
+      },
+      schema: SearchKnowledgeSchema,
+      handler: async (args) => {
+        const { query, project, min_score } = args;
+        const config = container.config.load();
+        const projects = container.projects.scan({
+          knownProjects: config.projects.filter((p) => !!p.path).map((p) => ({ name: p.name, path: p.path }))
+        });
+        const exposed = projects.filter((p) => container.config.isProjectExposed(config, p.name, p.sourcePath || p.path));
+        const targets = project ? exposed.filter((p) => p.name === project) : exposed;
+        const allResults = [];
+        for (const p of targets) {
+          const indexPath = path11.join(getKnowledgePath(p.name), "embeddings.json");
+          if (!fs11.existsSync(indexPath)) continue;
+          const results = await container.rag.search(indexPath, query, 10, min_score || 0);
+          allResults.push(...results.map((r) => ({ ...r, project: p.name })));
+        }
+        return { content: [{ type: "text", text: JSON.stringify({ results: allResults }, null, 2) }] };
+      }
+    },
+    {
+      definition: {
+        name: "search_code",
+        description: "Semantic search across code files. Returns code snippets with line numbers.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Search query" },
+            project: { type: "string", description: "Optional: limit to specific project" },
+            limit: { type: "number", description: "Max results (default 10)" },
+            max_tokens: { type: "number", description: "Optional: max tokens" },
+            min_score: { type: "number", description: "Optional: min score (0-1)" }
+          },
+          required: ["query"]
+        }
+      },
+      schema: SearchCodeSchema,
+      handler: async (args) => {
+        const { query, project, limit, min_score } = args;
+        const config = container.config.load();
+        const projects = container.projects.scan({
+          knownProjects: config.projects.filter((p) => !!p.path).map((p) => ({ name: p.name, path: p.path }))
+        });
+        const exposed = projects.filter((p) => container.config.isProjectExposed(config, p.name, p.sourcePath || p.path));
+        const targets = project ? exposed.filter((p) => p.name === project) : exposed;
+        const allResults = [];
+        for (const p of targets) {
+          const indexPath = path11.join(getKnowledgePath(p.name), "code-embeddings.json");
+          if (!fs11.existsSync(indexPath)) continue;
+          const results = await container.rag.search(indexPath, query, limit || 10, min_score || 0);
+          allResults.push(...results.map((r) => ({ ...r, project: p.name })));
+        }
+        if (allResults.length === 0) {
+          return {
+            content: [{ type: "text", text: "No code matches found. Run `index_knowledge` first to build the code index." }]
+          };
+        }
+        return { content: [{ type: "text", text: JSON.stringify({ results: allResults }, null, 2) }] };
+      }
+    },
+    {
+      definition: {
+        name: "find_related_files",
+        description: "Find files related through import/dependency relationships.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            file: { type: "string", description: "Path to the file" },
+            project: { type: "string", description: "Project name" },
+            include_imports: { type: "boolean", description: "Include imported files (default true)" },
+            include_imported_by: { type: "boolean", description: "Include importing files (default true)" },
+            depth: { type: "number", description: "Traversal depth (default 1)" }
+          },
+          required: ["file", "project"]
+        }
+      },
+      schema: FindRelatedSchema,
+      handler: async (args) => {
+        const params = args;
+        const config = container.config.load();
+        const projects = container.projects.scan({
+          knownProjects: config.projects.filter((p) => !!p.path).map((p) => ({ name: p.name, path: p.path }))
+        });
+        const project = projects.find((p) => p.name === params.project);
+        if (!project?.sourcePath) {
+          return { content: [{ type: "text", text: `Project "${params.project}" not found.` }], isError: true };
+        }
+        const graph = await container.dependencies.scanProject(project.sourcePath);
+        const related = container.dependencies.findRelated(params.file, graph, {
+          includeImports: params.include_imports,
+          includeImportedBy: params.include_imported_by,
+          depth: params.depth
+        });
+        return { content: [{ type: "text", text: JSON.stringify(related, null, 2) }] };
+      }
+    },
+    {
+      definition: {
+        name: "search_symbols",
+        description: "Search for code symbols (functions, classes, types) by name.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Symbol name" },
+            project: { type: "string", description: "Project name" },
+            type: { type: "string", description: "Filter by type" },
+            fuzzy: { type: "boolean", description: "Use fuzzy matching (default true)" },
+            limit: { type: "number", description: "Max results (default 10)" }
+          },
+          required: ["name", "project"]
+        }
+      },
+      schema: SearchSymbolsSchema,
+      handler: async (args) => {
+        const params = args;
+        const config = container.config.load();
+        const projects = container.projects.scan({
+          knownProjects: config.projects.filter((p) => !!p.path).map((p) => ({ name: p.name, path: p.path }))
+        });
+        const project = projects.find((p) => p.name === params.project);
+        if (!project?.sourcePath) {
+          return { content: [{ type: "text", text: `Project "${params.project}" not found.` }], isError: true };
+        }
+        const codeFiles = scanCodeFiles(project.sourcePath);
+        const results = codeFiles.map((f) => container.symbols.extract(f.content, f.path));
+        const matches = container.symbols.search(results, params.name, {
+          type: params.type,
+          fuzzy: params.fuzzy,
+          limit: params.limit
+        });
+        return { content: [{ type: "text", text: JSON.stringify({ matches }, null, 2) }] };
+      }
+    },
+    {
+      definition: {
+        name: "get_file_summary",
+        description: "Get a quick summary of a file (language, LOC, exports, imports, symbols).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            file: { type: "string", description: "Path to the file" },
+            project: { type: "string", description: "Project name" }
+          },
+          required: ["file", "project"]
+        }
+      },
+      schema: GetFileSummarySchema,
+      handler: async (args) => {
+        const { file, project } = args;
+        if (!fs11.existsSync(file)) {
+          return { content: [{ type: "text", text: `File not found: ${file}` }], isError: true };
+        }
+        const content = fs11.readFileSync(file, "utf-8");
+        const result = container.symbols.extract(content, file);
+        const lines = content.split("\n").length;
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              file,
+              language: result.language,
+              lines,
+              exports: result.exports,
+              imports: result.imports,
+              symbols: result.symbols.length
+            }, null, 2)
+          }]
+        };
+      }
+    },
+    {
+      definition: {
+        name: "get_context_bundle",
+        description: "Get bundled context: project context + knowledge + code in one call.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Natural language query" },
+            project: { type: "string", description: "Project name" },
+            task_slug: { type: "string", description: "Optional task slug" },
+            max_tokens: { type: "number", description: "Max tokens (default 4000)" },
+            include: { type: "object", description: "What to include", properties: {
+              project_context: { type: "boolean" },
+              knowledge: { type: "boolean" },
+              code: { type: "boolean" },
+              related_files: { type: "boolean" }
+            } }
+          },
+          required: ["query", "project"]
+        }
+      },
+      schema: GetContextBundleSchema,
+      handler: async (args) => {
+        const params = args;
+        const bundle = { project: params.project, query: params.query };
+        if (params.include?.project_context !== false) {
+          const contextFile = path11.join(getKnowledgePath(params.project), "context.md");
+          if (fs11.existsSync(contextFile)) bundle.projectContext = fs11.readFileSync(contextFile, "utf-8");
+        }
+        if (params.include?.knowledge !== false) {
+          const indexPath = path11.join(getKnowledgePath(params.project), "embeddings.json");
+          if (fs11.existsSync(indexPath)) {
+            bundle.knowledge = await container.rag.search(indexPath, params.query, 5);
+          }
+        }
+        if (params.include?.code !== false) {
+          const codeIndexPath = path11.join(getKnowledgePath(params.project), "code-embeddings.json");
+          if (fs11.existsSync(codeIndexPath)) {
+            bundle.code = await container.rag.search(codeIndexPath, params.query, 5);
+          }
+        }
+        return { content: [{ type: "text", text: JSON.stringify(bundle, null, 2) }] };
+      }
+    },
+    {
+      definition: {
+        name: "prefetch_task_context",
+        description: "Pre-gather all context for a task in a single call.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Project name" },
+            task_slug: { type: "string", description: "Task slug" },
+            max_tokens: { type: "number", description: "Max tokens (default 6000)" }
+          },
+          required: ["project", "task_slug"]
+        }
+      },
+      schema: PrefetchTaskContextSchema,
+      handler: async (args) => {
+        const { project, task_slug } = args;
+        const task = container.tasks.get(project, task_slug);
+        if (!task) {
+          return { content: [{ type: "text", text: `Task "${task_slug}" not found.` }], isError: true };
+        }
+        const bundle = { task };
+        const indexPath = path11.join(getKnowledgePath(project), "embeddings.json");
+        if (fs11.existsSync(indexPath) && task.title) {
+          bundle.knowledge = await container.rag.search(indexPath, task.title, 5);
+        }
+        return { content: [{ type: "text", text: JSON.stringify(bundle, null, 2) }] };
+      }
+    }
+  ];
+}
+function scanCodeFiles(root) {
+  const ig = loadGitignore(root);
+  const files = [];
+  const exts = [".ts", ".tsx", ".js", ".jsx"];
+  const scan = (dir) => {
+    try {
+      for (const entry of fs11.readdirSync(dir, { withFileTypes: true })) {
+        const full = path11.join(dir, entry.name);
+        const rel = path11.relative(root, full);
+        if (ig.ignores(rel)) continue;
+        if (entry.isDirectory()) scan(full);
+        else if (entry.isFile() && exts.includes(path11.extname(entry.name).toLowerCase())) {
+          try {
+            files.push({ path: full, content: fs11.readFileSync(full, "utf-8") });
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  };
+  scan(root);
+  return files;
+}
+var SearchKnowledgeSchema, SearchCodeSchema, FindRelatedSchema, SearchSymbolsSchema, GetFileSummarySchema, GetContextBundleSchema, PrefetchTaskContextSchema;
+var init_search = __esm({
+  "src/mcp/tools/search.ts"() {
+    "use strict";
+    init_paths();
+    init_gitignore();
+    SearchKnowledgeSchema = z3.object({
+      query: z3.string(),
+      project: z3.string().optional(),
+      max_tokens: z3.number().optional(),
+      min_score: z3.number().optional()
+    });
+    SearchCodeSchema = z3.object({
+      query: z3.string(),
+      project: z3.string().optional(),
+      limit: z3.number().optional(),
+      max_tokens: z3.number().optional(),
+      min_score: z3.number().optional()
+    });
+    FindRelatedSchema = z3.object({
+      file: z3.string(),
+      project: z3.string(),
+      include_imports: z3.boolean().optional(),
+      include_imported_by: z3.boolean().optional(),
+      depth: z3.number().optional()
+    });
+    SearchSymbolsSchema = z3.object({
+      name: z3.string(),
+      project: z3.string(),
+      type: z3.string().optional(),
+      fuzzy: z3.boolean().optional(),
+      limit: z3.number().optional()
+    });
+    GetFileSummarySchema = z3.object({
+      file: z3.string(),
+      project: z3.string()
+    });
+    GetContextBundleSchema = z3.object({
+      query: z3.string(),
+      project: z3.string(),
+      task_slug: z3.string().optional(),
+      max_tokens: z3.number().optional(),
+      include: z3.object({
+        project_context: z3.boolean().optional(),
+        knowledge: z3.boolean().optional(),
+        code: z3.boolean().optional(),
+        related_files: z3.boolean().optional()
+      }).optional()
+    });
+    PrefetchTaskContextSchema = z3.object({
+      project: z3.string(),
+      task_slug: z3.string(),
+      max_tokens: z3.number().optional()
+    });
+  }
+});
+
+// src/mcp/tools/task.ts
+import { z as z4 } from "zod";
+function createTaskTools(container) {
+  return [
+    {
+      definition: { name: "list_tasks", description: "List all tasks for a project.", inputSchema: { type: "object", properties: { project: { type: "string", description: "Project name" } }, required: ["project"] } },
+      schema: ProjectSchema,
+      handler: async (args) => {
+        const { project } = args;
+        const tasks = container.tasks.list(project);
+        return { content: [{ type: "text", text: JSON.stringify(tasks, null, 2) }] };
+      }
+    },
+    {
+      definition: { name: "get_task", description: "Get details of a specific task.", inputSchema: { type: "object", properties: { project: { type: "string", description: "Project name" }, task_slug: { type: "string", description: "Task slug" } }, required: ["project", "task_slug"] } },
+      schema: TaskSchema,
+      handler: async (args) => {
+        const { project, task_slug } = args;
+        const task = container.tasks.get(project, task_slug);
+        if (!task) return { content: [{ type: "text", text: `Task '${task_slug}' not found.` }], isError: true };
+        return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
+      }
+    },
+    {
+      definition: { name: "create_task", description: "Create a new task.", inputSchema: { type: "object", properties: { project: { type: "string", description: "Project name" }, task_slug: { type: "string", description: "Task slug (kebab-case)" }, title: { type: "string", description: "Task title" }, summary: { type: "string", description: "Brief summary" } }, required: ["project", "task_slug"] } },
+      schema: CreateTaskSchema,
+      handler: async (args) => {
+        const { project, task_slug, title, summary } = args;
+        const task = container.tasks.create(project, task_slug, { title, summary });
+        return { content: [{ type: "text", text: `Task '${task_slug}' created.
+${JSON.stringify(task, null, 2)}` }] };
+      }
+    },
+    {
+      definition: { name: "update_task", description: "Update an existing task.", inputSchema: { type: "object", properties: { project: { type: "string", description: "Project name" }, task_slug: { type: "string", description: "Task slug" }, updates: { type: "object", description: "Fields to update" } }, required: ["project", "task_slug", "updates"] } },
+      schema: UpdateTaskSchema,
+      handler: async (args) => {
+        const { project, task_slug, updates } = args;
+        const task = container.tasks.update(project, task_slug, updates);
+        if (!task) return { content: [{ type: "text", text: `Task '${task_slug}' not found.` }], isError: true };
+        return { content: [{ type: "text", text: `Task '${task_slug}' updated.
+${JSON.stringify(task, null, 2)}` }] };
+      }
+    },
+    {
+      definition: { name: "delete_task", description: "Delete a task.", inputSchema: { type: "object", properties: { project: { type: "string", description: "Project name" }, task_slug: { type: "string", description: "Task slug" } }, required: ["project", "task_slug"] } },
+      schema: TaskSchema,
+      handler: async (args) => {
+        const { project, task_slug } = args;
+        const ok = container.tasks.delete(project, task_slug);
+        return { content: [{ type: "text", text: ok ? `Task '${task_slug}' deleted.` : `Failed to delete '${task_slug}'.` }] };
+      }
+    },
+    {
+      definition: { name: "search_tasks", description: "Search tasks by keyword, status, agent, or date.", inputSchema: { type: "object", properties: { project: { type: "string", description: "Project name" }, keyword: { type: "string" }, status: { type: "string" }, agent: { type: "string" }, since: { type: "string" }, limit: { type: "number" } }, required: ["project"] } },
+      schema: SearchTasksSchema,
+      handler: async (args) => {
+        const params = args;
+        const results = container.tasks.search(params.project, params);
+        return { content: [{ type: "text", text: JSON.stringify({ count: results.length, tasks: results }, null, 2) }] };
+      }
+    },
+    {
+      definition: { name: "validate_phase", description: "Check if a task phase has prerequisites complete.", inputSchema: { type: "object", properties: { project: { type: "string", description: "Project name" }, task_slug: { type: "string", description: "Task slug" }, phase: { type: "string", description: "Phase to validate" } }, required: ["project", "task_slug", "phase"] } },
+      schema: ValidatePhaseSchema,
+      handler: async (args) => {
+        const { project, task_slug, phase } = args;
+        const result = container.tasks.validatePhase(project, task_slug, phase);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    }
+  ];
+}
+var ProjectSchema, TaskSchema, CreateTaskSchema, UpdateTaskSchema, SearchTasksSchema, ValidatePhaseSchema;
+var init_task = __esm({
+  "src/mcp/tools/task.ts"() {
+    "use strict";
+    ProjectSchema = z4.object({ project: z4.string() });
+    TaskSchema = z4.object({ project: z4.string(), task_slug: z4.string() });
+    CreateTaskSchema = z4.object({ project: z4.string(), task_slug: z4.string(), title: z4.string().optional(), summary: z4.string().optional() });
+    UpdateTaskSchema = z4.object({ project: z4.string(), task_slug: z4.string(), updates: z4.record(z4.string(), z4.unknown()) });
+    SearchTasksSchema = z4.object({ project: z4.string(), keyword: z4.string().optional(), status: z4.string().optional(), agent: z4.string().optional(), since: z4.string().optional(), limit: z4.number().optional() });
+    ValidatePhaseSchema = z4.object({ project: z4.string(), task_slug: z4.string(), phase: z4.enum(["research", "planning", "execution", "documentation"]) });
+  }
+});
+
+// src/mcp/tools/session.ts
+import { z as z5 } from "zod";
+function createSessionTools(container) {
+  return [
+    {
+      definition: {
+        name: "start_session",
+        description: "Start an agent session for task tracking.",
+        inputSchema: { type: "object", properties: { project: { type: "string" }, task_slug: { type: "string" }, agent: { type: "string" }, phase: { type: "string" } }, required: ["project", "task_slug", "agent", "phase"] }
+      },
+      schema: StartSessionSchema,
+      handler: async (args) => {
+        const { project, task_slug, agent, phase } = args;
+        const result = container.sessions.start(project, task_slug, agent, phase);
+        return { content: [{ type: "text", text: result.message }], isError: !result.success };
+      }
+    },
+    {
+      definition: {
+        name: "end_session",
+        description: "End an agent session.",
+        inputSchema: { type: "object", properties: { project: { type: "string" }, task_slug: { type: "string" } }, required: ["project", "task_slug"] }
+      },
+      schema: EndSessionSchema,
+      handler: async (args) => {
+        const { project, task_slug } = args;
+        const result = container.sessions.end(project, task_slug);
+        return { content: [{ type: "text", text: result.message }], isError: !result.success };
+      }
+    },
+    {
+      definition: {
+        name: "update_agent_todos",
+        description: "Update the agent todo list for a task.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string" },
+            task_slug: { type: "string" },
+            phase: { type: "string" },
+            agent: { type: "string" },
+            items: { type: "array", description: "Todo items", items: { type: "object", properties: { id: { type: "string" }, content: { type: "string" }, status: { type: "string" }, priority: { type: "string" } }, required: ["id", "content", "status", "priority"] } }
+          },
+          required: ["project", "task_slug", "phase", "agent", "items"]
+        }
+      },
+      schema: UpdateTodosSchema,
+      handler: async (args) => {
+        const { project, task_slug, phase, agent, items } = args;
+        const result = container.sessions.updateTodos(project, task_slug, phase, agent, items);
+        return { content: [{ type: "text", text: result.message }], isError: !result.success };
+      }
+    }
+  ];
+}
+var StartSessionSchema, EndSessionSchema, UpdateTodosSchema;
+var init_session = __esm({
+  "src/mcp/tools/session.ts"() {
+    "use strict";
+    StartSessionSchema = z5.object({
+      project: z5.string(),
+      task_slug: z5.string(),
+      agent: z5.string(),
+      phase: z5.string()
+    });
+    EndSessionSchema = z5.object({ project: z5.string(), task_slug: z5.string() });
+    UpdateTodosSchema = z5.object({
+      project: z5.string(),
+      task_slug: z5.string(),
+      phase: z5.string(),
+      agent: z5.string(),
+      items: z5.array(z5.object({
+        id: z5.string(),
+        content: z5.string(),
+        status: z5.enum(["pending", "in_progress", "completed"]),
+        priority: z5.enum(["high", "medium", "low"])
+      }))
+    });
+  }
+});
+
+// src/mcp/tools/agent.ts
+import { z as z6 } from "zod";
+function createAgentTools(container) {
+  return [
+    {
+      definition: {
+        name: "list_agents",
+        description: "List available agents and their arguments.",
+        inputSchema: { type: "object", properties: {} }
+      },
+      handler: async () => {
+        const prompts = container.prompts.getAllPrompts();
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(prompts.map((p) => ({
+              name: p.name,
+              id: p.id,
+              description: p.description,
+              arguments: p.arguments
+            })), null, 2) + "\n\nTip: Use `get_agent_prompt` with the agent name or ID."
+          }]
+        };
+      }
+    },
+    {
+      definition: {
+        name: "get_agent_prompt",
+        description: "Get the system prompt for a specific agent.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            agent: { type: "string", description: "Agent name or ID" },
+            args: { type: "object", description: "Arguments for the prompt" }
+          },
+          required: ["agent"]
+        }
+      },
+      schema: GetAgentPromptSchema,
+      handler: async (args) => {
+        const { agent, args: promptArgs } = args;
+        const promptDef = container.prompts.getPrompt(agent);
+        if (!promptDef) {
+          const available = container.prompts.getAllPrompts().map((p) => `${p.name} (id: ${p.id})`).join(", ");
+          return { content: [{ type: "text", text: `Agent not found: ${agent}. Available: ${available}` }], isError: true };
+        }
+        const activeProject = container.projects.findClosest();
+        const context = {
+          dataPath: activeProject ? getDataPath(activeProject.name) + "/" : ".ce-workflow/",
+          home: getHome(),
+          workspaceRoot: activeProject?.sourcePath || activeProject?.path || process.cwd(),
+          workspaceName: activeProject?.name || "current-project"
+        };
+        const { rendered } = container.prompts.renderWithContext(
+          promptDef.content,
+          promptArgs || {},
+          context
+        );
+        return { content: [{ type: "text", text: rendered }] };
+      }
+    }
+  ];
+}
+var GetAgentPromptSchema;
+var init_agent = __esm({
+  "src/mcp/tools/agent.ts"() {
+    "use strict";
+    init_paths();
+    GetAgentPromptSchema = z6.object({
+      agent: z6.string(),
+      args: z6.record(z6.string(), z6.string()).optional()
+    });
+  }
+});
+
+// src/mcp/tools/cleanup.ts
+import { z as z7 } from "zod";
+import * as fs12 from "fs";
+import * as path12 from "path";
+function createCleanupTools(container) {
+  return [
+    {
+      definition: {
+        name: "cleanup_task",
+        description: "Cleanup task(s) by extracting knowledge and deleting artifacts.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Project name" },
+            task_slug: { type: "string", description: "Single task slug" },
+            task_slugs: { type: "array", items: { type: "string" }, description: "Multiple task slugs" },
+            cleanup_all: { type: "boolean", description: "Cleanup all tasks" }
+          },
+          required: ["project"]
+        }
+      },
+      schema: CleanupTaskSchema,
+      handler: async (args) => {
+        const { project, task_slug, task_slugs, cleanup_all } = args;
+        let slugs = [];
+        if (cleanup_all) {
+          slugs = container.tasks.list(project).map((t) => t.task_slug);
+        } else if (task_slugs?.length) {
+          slugs = task_slugs;
+        } else if (task_slug) {
+          slugs = [task_slug];
+        }
+        if (slugs.length === 0) {
+          return { content: [{ type: "text", text: "No tasks specified for cleanup." }], isError: true };
+        }
+        if (slugs.length > 10) {
+          return { content: [{ type: "text", text: `Too many tasks (${slugs.length}). Max 10 per batch.` }], isError: true };
+        }
+        let successCount = 0;
+        const errors = [];
+        for (const slug of slugs) {
+          const task = container.tasks.get(project, slug);
+          if (!task) {
+            errors.push(`Task '${slug}' not found.`);
+            continue;
+          }
+          const taskDir = path12.join(getTasksPath(project), slug);
+          const artifacts = [];
+          for (const phase of ["research", "planning", "execution", "docs"]) {
+            const artPath = path12.join(taskDir, phase, `${slug}-${phase}.md`);
+            if (fs12.existsSync(artPath)) artifacts.push(phase);
+          }
+          successCount++;
+        }
+        let msg = `Loaded ${successCount} task(s) for cleanup.`;
+        if (errors.length > 0) msg += `
+Errors: ${errors.join("; ")}`;
+        msg += "\n\nThe cleanup agent will now extract knowledge, check for duplicates, and delete task directories.";
+        return { content: [{ type: "text", text: msg }] };
+      }
+    }
+  ];
+}
+var CleanupTaskSchema;
+var init_cleanup = __esm({
+  "src/mcp/tools/cleanup.ts"() {
+    "use strict";
+    init_paths();
+    CleanupTaskSchema = z7.object({
+      project: z7.string(),
+      task_slug: z7.string().optional(),
+      task_slugs: z7.array(z7.string()).optional(),
+      cleanup_all: z7.boolean().optional()
+    });
+  }
+});
+
+// src/mcp/tools/index.ts
+function createAllTools(container) {
+  return [
+    ...createProjectTools(container),
+    ...createSearchTools(container),
+    ...createTaskTools(container),
+    ...createSessionTools(container),
+    ...createAgentTools(container),
+    ...createCleanupTools(container)
+  ];
+}
+var init_tools = __esm({
+  "src/mcp/tools/index.ts"() {
+    "use strict";
+    init_project();
+    init_search();
+    init_task();
+    init_session();
+    init_agent();
+    init_cleanup();
+  }
+});
+
+// src/mcp/handlers/resources.ts
+import "@modelcontextprotocol/sdk/server/index.js";
+import {
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import * as fs13 from "fs";
+import * as path13 from "path";
+function registerResourceHandlers(server, container) {
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    container.logger.debug("Listing resources");
+    const config = container.config.load();
+    const projects = container.projects.scan();
+    const resources = [];
+    resources.push({
+      uri: "ce://projects",
+      name: "Project List",
+      description: "List of all projects exposed via MCP",
+      mimeType: "application/json"
+    });
+    for (const project of projects) {
+      if (!container.config.isProjectExposed(config, project.name, project.path)) continue;
+      const permissions = container.config.getProjectPermissions(config, project.name, project.path);
+      if (permissions.knowledge) {
+        resources.push({
+          uri: `ce://projects/${project.name}/context`,
+          name: `${project.name} - Project Context`,
+          description: `Project context and architecture for ${project.name}`,
+          mimeType: "text/markdown"
+        });
+      }
+      if (permissions.tasks) {
+        resources.push({
+          uri: `ce://projects/${project.name}/tasks`,
+          name: `${project.name} - Tasks`,
+          description: `Task list and status for ${project.name}`,
+          mimeType: "application/json"
+        });
+      }
+    }
+    return { resources };
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    container.logger.info(`Reading resource: ${uri}`);
+    try {
+      if (uri === "ce://projects") {
+        const config = container.config.load();
+        const projects = container.projects.scan().filter((p) => container.config.isProjectExposed(config, p.name, p.path));
+        return {
+          contents: [{
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify(projects.map((p) => ({
+              name: p.name,
+              source: p.source,
+              path: p.path
+            })), null, 2)
+          }]
+        };
+      }
+      const projectMatch = uri.match(/^ce:\/\/projects\/([^/]+)\/(.+)$/);
+      if (projectMatch && projectMatch[1] && projectMatch[2]) {
+        const projectName = projectMatch[1];
+        const resourceType = projectMatch[2];
+        const content = resourceType === "context" ? readProjectContext(projectName) : JSON.stringify(container.tasks.list(projectName), null, 2);
+        if (content === null) throw new Error(`Resource not found: ${uri}`);
+        return {
+          contents: [{
+            uri,
+            mimeType: resourceType === "tasks" ? "application/json" : "text/markdown",
+            text: content
+          }]
+        };
+      }
+      throw new Error(`Unknown resource: ${uri}`);
+    } catch (error) {
+      container.logger.error(`Failed to read resource: ${uri}`, error);
+      throw error;
+    }
+  });
+}
+function readProjectContext(projectName) {
+  const knowledgeDir = getKnowledgePath(projectName);
+  if (!fs13.existsSync(knowledgeDir)) return null;
+  const parts = [];
+  try {
+    for (const file of fs13.readdirSync(knowledgeDir)) {
+      if (!file.endsWith(".md")) continue;
+      const content = fs13.readFileSync(path13.join(knowledgeDir, file), "utf-8");
+      parts.push(content);
+    }
+  } catch {
+  }
+  return parts.length > 0 ? parts.join("\n\n---\n\n") : null;
+}
+var init_resources = __esm({
+  "src/mcp/handlers/resources.ts"() {
+    "use strict";
+    init_paths();
+  }
+});
+
+// src/mcp/handlers/prompts.ts
+import "@modelcontextprotocol/sdk/server/index.js";
+import {
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+function registerPromptHandlers(server, container) {
+  server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    container.logger.debug("Listing prompts");
+    const prompts = container.prompts.getAllPrompts();
+    return {
+      prompts: prompts.map((p) => ({
+        name: p.name,
+        description: p.description,
+        arguments: p.arguments.map((a) => ({
+          name: a.name,
+          description: a.description,
+          required: a.required
+        }))
+      }))
+    };
+  });
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    container.logger.info(`Getting prompt: ${name}`, args);
+    const promptDef = container.prompts.getPrompt(name);
+    if (!promptDef) {
+      container.logger.error(`Prompt not found: ${name}`);
+      throw new Error(`Prompt not found: ${name}`);
+    }
+    try {
+      const providedArgs = args || {};
+      const missingArgs = promptDef.arguments.filter((a) => a.required && !providedArgs[a.name]).map((a) => a.name);
+      if (missingArgs.length > 0) {
+        throw new Error(`Missing required arguments: ${missingArgs.join(", ")}`);
+      }
+      const renderArgs = {};
+      for (const [key, val] of Object.entries(providedArgs)) {
+        renderArgs[key] = String(val);
+      }
+      const activeProject = container.projects.findClosest();
+      const context = {
+        dataPath: activeProject ? getDataPath(activeProject.name) + "/" : ".ce-workflow/",
+        home: getHome(),
+        workspaceRoot: activeProject?.sourcePath || activeProject?.path || process.cwd(),
+        workspaceName: activeProject?.name || "current-project"
+      };
+      const { rendered } = container.prompts.renderWithContext(
+        promptDef.content,
+        renderArgs,
+        context
+      );
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: rendered
+            }
+          }
+        ]
+      };
+    } catch (error) {
+      container.logger.error(`Failed to get prompt: ${name}`, error);
+      throw error;
+    }
+  });
+}
+var init_prompts = __esm({
+  "src/mcp/handlers/prompts.ts"() {
+    "use strict";
+    init_paths();
+  }
+});
+
+// src/mcp/server.ts
+import { Server as Server3 } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import * as fs14 from "fs";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var MCPServer;
+var init_server = __esm({
+  "src/mcp/server.ts"() {
+    "use strict";
+    init_registry();
+    init_tools();
+    init_resources();
+    init_prompts();
+    MCPServer = class {
+      constructor(container) {
+        this.container = container;
+        this.registry = new ToolRegistry();
+      }
+      server = null;
+      registry;
+      configWatcher = null;
+      running = false;
+      async start(options = {}) {
+        const logger = this.container.logger;
+        try {
+          logger.info("Starting MCP Server...");
+          process.on("uncaughtException", (error) => {
+            logger.error("Uncaught Exception", error);
+          });
+          process.on("unhandledRejection", (reason) => {
+            logger.error("Unhandled Rejection", reason);
+          });
+          const config = this.container.config.load();
+          const tools = createAllTools(this.container);
+          this.registry.registerMany(tools);
+          this.server = new Server3(
+            { name: "ce-mcp-hub", version: "0.4.0" },
+            { capabilities: { resources: {}, tools: {}, prompts: {} } }
+          );
+          this.server.onerror = (error) => {
+            logger.error("MCP Server Error", error);
+          };
+          this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: this.registry.listTools()
+          }));
+          this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args, _meta } = request.params;
+            const resolvedArgs = this.injectCallerContext(args ?? {}, _meta);
+            logger.info(`Tool call: ${name}`, resolvedArgs);
+            return this.registry.dispatch(name, resolvedArgs);
+          });
+          registerResourceHandlers(this.server, this.container);
+          registerPromptHandlers(this.server, this.container);
+          if (!options.interactive) {
+            const configPath = this.container.config.getConfigFilePath();
+            try {
+              if (fs14.existsSync(configPath)) {
+                this.configWatcher = fs14.watch(configPath, () => {
+                  this.container.config.invalidate();
+                  logger.info("Config file changed, refreshed");
+                });
+                logger.info("Watching config file for changes", { configPath });
+              }
+            } catch (err) {
+              logger.warn("Failed to watch config file", { error: String(err) });
+            }
+          }
+          if (!options.interactive) {
+            const transport = new StdioServerTransport();
+            await this.server.connect(transport);
+          } else {
+            logger.info("Running in interactive mode (stdio transport detached)");
+          }
+          this.running = true;
+          const projects = this.container.projects.scan();
+          const exposed = projects.filter((p) => this.container.config.isProjectExposed(config, p.name, p.path)).map((p) => p.name).join(", ");
+          logger.info(`CE MCP Hub started (pid: ${process.pid})`, { exposedProjects: exposed });
+          if (!options.interactive) {
+            console.error(`CE MCP Hub started (pid: ${process.pid})`);
+            console.error(`Exposed projects: ${exposed}`);
+          }
+          return { port: config.server.port, pid: process.pid };
+        } catch (error) {
+          logger.error("Failed to start MCP server", error);
+          throw error;
+        }
+      }
+      stop() {
+        if (this.configWatcher) {
+          this.configWatcher.close();
+          this.configWatcher = null;
+        }
+        if (this.server) {
+          this.container.logger.info("Stopping MCP Server...");
+          this.server.close();
+          this.server = null;
+        }
+        this.running = false;
+        this.container.logger.info("CE MCP Hub stopped");
+      }
+      isRunning() {
+        return this.running;
+      }
+      getRegistry() {
+        return this.registry;
+      }
+      /**
+       * Auto-inject project from caller metadata when not explicitly provided.
+       * MCP clients may pass _meta with workspaceRoot or cwd.
+       */
+      injectCallerContext(args, meta) {
+        if (args["project"] || !meta) return args;
+        const cwd = meta["workspaceRoot"] ?? meta["cwd"] ?? meta["rootUri"];
+        if (!cwd) return args;
+        const project = this.container.projects.findClosest(cwd);
+        if (!project) return args;
+        return { ...args, project: project.name };
+      }
+    };
+  }
+});
+
+// src/ui/components/header.tsx
+import "react";
+import { Box, Text } from "ink";
+import { jsx } from "react/jsx-runtime";
+var Header;
+var init_header = __esm({
+  "src/ui/components/header.tsx"() {
+    "use strict";
+    Header = () => /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingBottom: 1, children: /* @__PURE__ */ jsx(Box, { borderStyle: "double", borderColor: "white", paddingX: 2, justifyContent: "center", children: /* @__PURE__ */ jsx(Text, { bold: true, color: "white", children: " CE MCP Hub " }) }) });
+  }
+});
+
+// src/lib/drift-service.ts
+import * as fs15 from "fs";
+import * as path14 from "path";
+import * as crypto from "crypto";
+var DriftService;
+var init_drift_service = __esm({
+  "src/lib/drift-service.ts"() {
+    "use strict";
+    DriftService = class {
+      static CHECKSUM_FILENAME = ".ce-checksums.json";
+      static calculateHash(filePath) {
+        const content = fs15.readFileSync(filePath);
+        return crypto.createHash("md5").update(content).digest("hex");
+      }
+      static getManifestPath(projectPath) {
+        return path14.join(projectPath, this.CHECKSUM_FILENAME);
+      }
+      static loadManifest(projectPath) {
+        const manifestPath = this.getManifestPath(projectPath);
+        if (!fs15.existsSync(manifestPath)) return {};
+        try {
+          return JSON.parse(fs15.readFileSync(manifestPath, "utf8"));
+        } catch {
+          return {};
+        }
+      }
+      static saveManifest(projectPath, manifest) {
+        fs15.writeFileSync(this.getManifestPath(projectPath), JSON.stringify(manifest, null, 2));
+      }
+      static generateManifest(projectPath, files) {
+        const manifest = {};
+        for (const file of files) {
+          const fullPath = path14.join(projectPath, file);
+          if (fs15.existsSync(fullPath)) {
+            const stats = fs15.statSync(fullPath);
+            manifest[file] = {
+              hash: this.calculateHash(fullPath),
+              mtime: stats.mtimeMs
+            };
+          }
+        }
+        return manifest;
+      }
+      static detectModifiedFiles(projectPath) {
+        const manifest = this.loadManifest(projectPath);
+        const modified = [];
+        const deleted = [];
+        for (const [relPath, entry] of Object.entries(manifest)) {
+          const fullPath = path14.join(projectPath, relPath);
+          if (!fs15.existsSync(fullPath)) {
+            deleted.push(relPath);
+            continue;
+          }
+          const stats = fs15.statSync(fullPath);
+          if (stats.mtimeMs === entry.mtime) continue;
+          const currentHash = this.calculateHash(fullPath);
+          if (currentHash !== entry.hash) {
+            modified.push(relPath);
+          }
+        }
+        return { modified, deleted };
+      }
+      static checkDrift(projectPath, currentVersion, runningVersion) {
+        const { modified, deleted } = this.detectModifiedFiles(projectPath);
+        let type = "none";
+        let hasDrift = false;
+        if (currentVersion !== runningVersion) {
+          hasDrift = true;
+          type = "version";
+        } else if (modified.length > 0 || deleted.length > 0) {
+          hasDrift = true;
+          type = "modified";
+        }
+        return {
+          hasDrift,
+          type,
+          modifiedFiles: modified,
+          deletedFiles: deleted,
+          version: {
+            current: currentVersion || "0.0.0",
+            running: runningVersion
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/ui/providers/service-provider.tsx
+import { createContext, useContext } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function useServices() {
+  const context = useContext(ServiceContext);
+  if (!context) throw new Error("useServices must be used within a ServiceProvider");
+  return context;
+}
+var ServiceContext, ServiceProvider;
+var init_service_provider = __esm({
+  "src/ui/providers/service-provider.tsx"() {
+    "use strict";
+    ServiceContext = createContext(null);
+    ServiceProvider = ({ container, children }) => {
+      return /* @__PURE__ */ jsx2(ServiceContext.Provider, { value: container, children });
+    };
+  }
+});
+
+// src/ui/providers/config-provider.tsx
+import { createContext as createContext2, useContext as useContext2, useState, useCallback, useMemo, useEffect } from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function useConfig() {
+  const context = useContext2(ConfigContext);
+  if (!context) throw new Error("useConfig must be used within a ConfigProvider");
+  return context;
+}
+var ConfigContext, ConfigProvider;
+var init_config_provider = __esm({
+  "src/ui/providers/config-provider.tsx"() {
+    "use strict";
+    init_drift_service();
+    init_service_provider();
+    ConfigContext = createContext2(null);
+    ConfigProvider = ({ children }) => {
+      const container = useServices();
+      const [config, setConfig] = useState(() => container.config.load());
+      const [projects, setProjects] = useState(() => container.projects.scan());
+      const [driftReports, setDriftReports] = useState({});
+      const refresh = useCallback(() => {
+        container.config.invalidate();
+        setConfig(container.config.load());
+        setProjects(container.projects.refresh());
+      }, [container]);
+      const checkAllDrift = useCallback(() => {
+        const reports = {};
+        for (const project of projects) {
+          const projectConfig = container.config.findProject(config, { name: project.name, path: project.path });
+          const currentVersion = projectConfig?.last_synced_version;
+          reports[project.path] = DriftService.checkDrift(project.dataPath, currentVersion, "0.4.0");
+        }
+        setDriftReports(reports);
+      }, [projects, config, container]);
+      useEffect(() => {
+        checkAllDrift();
+      }, [checkAllDrift]);
+      const exposedProjects = useMemo(
+        () => projects.filter((p) => container.config.isProjectExposed(config, p.name, p.path)),
+        [projects, config, container]
+      );
+      const value = useMemo(() => ({
+        config,
+        projects,
+        exposedProjects,
+        driftReports,
+        refresh,
+        checkAllDrift
+      }), [config, projects, exposedProjects, driftReports, refresh, checkAllDrift]);
+      return /* @__PURE__ */ jsx3(ConfigContext.Provider, { value, children });
+    };
+  }
+});
+
+// src/ui/hooks/use-config.ts
+var init_use_config = __esm({
+  "src/ui/hooks/use-config.ts"() {
+    "use strict";
+    init_config_provider();
+  }
+});
+
+// src/ui/hooks/use-services.ts
+var init_use_services = __esm({
+  "src/ui/hooks/use-services.ts"() {
+    "use strict";
+    init_service_provider();
+  }
+});
+
+// src/ui/lib/ui-helpers.ts
+var getStatusIcon, getStatusColor, getChecklistProgress, getCheckbox, getProgressBar, getFolderIcon, getAgentStatusIcon, getPhaseIcon, getTreeBranch, formatRelativeTime, getTodoStatusIcon;
+var init_ui_helpers = __esm({
+  "src/ui/lib/ui-helpers.ts"() {
+    "use strict";
+    getStatusIcon = (status) => {
+      const icons = {
+        pending: "\u23F3",
+        in_progress: "\u{1F504}",
+        blocked: "\u{1F6AB}",
+        complete: "\u2705"
+      };
+      return icons[status] || "\u25CB";
+    };
+    getStatusColor = (status) => {
+      const colors = {
+        pending: "yellow",
+        in_progress: "yellow",
+        blocked: "red",
+        complete: "green"
+      };
+      return colors[status] || "white";
+    };
+    getChecklistProgress = (checklist) => {
+      if (!checklist || checklist.length === 0) return { completed: 0, total: 0, percentage: 0 };
+      const completed = checklist.filter((item) => item.status === "done").length;
+      return { completed, total: checklist.length, percentage: Math.round(completed / checklist.length * 100) };
+    };
+    getCheckbox = (status) => status === "done" ? "\u2611" : "\u2610";
+    getProgressBar = (percentage, length = 10) => {
+      const filled = Math.floor(percentage / 100 * length);
+      return "\u2588".repeat(filled) + "\u2591".repeat(length - filled);
+    };
+    getFolderIcon = (isOpen) => isOpen ? "\u{1F4C2}" : "\u{1F4C1}";
+    getAgentStatusIcon = (status) => {
+      const icons = { complete: "\u2713", in_progress: "\u27F3", pending: "\u25CB", blocked: "\u2715" };
+      return icons[status] || "\u2014";
+    };
+    getPhaseIcon = (agent) => {
+      const icons = { research: "\u{1F52C}", planning: "\u{1F4DD}", executor: "\u26A1", documentation: "\u{1F4DA}" };
+      return icons[agent] || "\u{1F527}";
+    };
+    getTreeBranch = (isLast) => isLast ? "\u2514\u2500" : "\u251C\u2500";
+    formatRelativeTime = (dateString) => {
+      if (!dateString) return "\u2014";
+      const date = Date.parse(dateString);
+      if (isNaN(date)) return "\u2014";
+      const diffMs = Date.now() - date;
+      const diffMins = Math.floor(diffMs / 6e4);
+      const diffHours = Math.floor(diffMs / 36e5);
+      const diffDays = Math.floor(diffMs / 864e5);
+      if (diffMins < 1) return "just now";
+      if (diffMins < 60) return `${diffMins}m ago`;
+      if (diffHours < 24) return `${diffHours}h ago`;
+      if (diffDays < 7) return `${diffDays}d ago`;
+      return `${Math.floor(diffDays / 7)}w ago`;
+    };
+    getTodoStatusIcon = (status) => {
+      const icons = { completed: "\u2713", in_progress: "\u27F3", pending: "\u25CB" };
+      return icons[status] || "\u25CB";
+    };
+  }
+});
+
+// src/ui/views/overview.tsx
+import { useMemo as useMemo2, memo } from "react";
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx4, jsxs } from "react/jsx-runtime";
+var getElapsedTime, Overview;
+var init_overview = __esm({
+  "src/ui/views/overview.tsx"() {
+    "use strict";
+    init_header();
+    init_use_config();
+    init_use_services();
+    init_ui_helpers();
+    getElapsedTime = (startedAt) => {
+      const start = Date.parse(startedAt);
+      if (isNaN(start)) return "";
+      const elapsed = Date.now() - start;
+      const mins = Math.floor(elapsed / 6e4);
+      if (mins < 60) return `${mins}m`;
+      const hours = Math.floor(mins / 60);
+      return `${hours}h ${mins % 60}m`;
+    };
+    Overview = memo(({ serverStatus, stats, logs }) => {
+      const { projects } = useConfig();
+      const container = useServices();
+      const activeTasks = useMemo2(() => {
+        const active = [];
+        for (const p of projects) {
+          const tasks = container.tasks.list(p.name);
+          const inProgress = tasks.filter((t) => t.status === "in_progress");
+          for (const t of inProgress) {
+            const session = container.sessions.getSession(p.name, t.task_slug);
+            const todos = container.sessions.getTodos(p.name, t.task_slug);
+            active.push({
+              project: p.name,
+              title: t.title || t.task_slug,
+              slug: t.task_slug,
+              session,
+              todos
+            });
+          }
+        }
+        return active;
+      }, [projects, container]);
+      const recentLogs = useMemo2(() => logs.slice(-5).reverse(), [logs]);
+      return /* @__PURE__ */ jsxs(Box2, { flexDirection: "column", flexGrow: 1, children: [
+        /* @__PURE__ */ jsx4(Header, {}),
+        /* @__PURE__ */ jsxs(Box2, { borderStyle: "round", paddingX: 1, borderColor: "white", flexDirection: "column", flexGrow: 1, children: [
+          /* @__PURE__ */ jsxs(Box2, { justifyContent: "space-between", children: [
+            /* @__PURE__ */ jsxs(Box2, { flexDirection: "column", width: "50%", children: [
+              /* @__PURE__ */ jsx4(Text2, { bold: true, color: "cyan", children: "System Cockpit" }),
+              /* @__PURE__ */ jsxs(Box2, { marginTop: 1, children: [
+                /* @__PURE__ */ jsx4(Text2, { children: "MCP Server: " }),
+                /* @__PURE__ */ jsx4(Text2, { color: "green", children: "Running" }),
+                /* @__PURE__ */ jsxs(Text2, { color: "dim", children: [
+                  " (Port: ",
+                  serverStatus.port,
+                  ")"
+                ] })
+              ] }),
+              /* @__PURE__ */ jsxs(Box2, { children: [
+                /* @__PURE__ */ jsx4(Text2, { children: "Projects: " }),
+                /* @__PURE__ */ jsxs(Text2, { children: [
+                  stats.exposedProjects,
+                  " / ",
+                  stats.totalProjects,
+                  " exposed"
+                ] })
+              ] })
+            ] }),
+            /* @__PURE__ */ jsxs(Box2, { flexDirection: "column", width: "50%", paddingLeft: 2, children: [
+              /* @__PURE__ */ jsx4(Text2, { bold: true, color: "magenta", children: "Slash Commands" }),
+              /* @__PURE__ */ jsxs(Box2, { marginTop: 1, flexDirection: "column", children: [
+                /* @__PURE__ */ jsxs(Text2, { color: "cyan", children: [
+                  "/ce_init ",
+                  /* @__PURE__ */ jsx4(Text2, { color: "dim", children: "- Setup workspace" })
+                ] }),
+                /* @__PURE__ */ jsxs(Text2, { color: "cyan", children: [
+                  "/ce_research ",
+                  /* @__PURE__ */ jsx4(Text2, { color: "dim", children: "- Clarify requirements" })
+                ] }),
+                /* @__PURE__ */ jsxs(Text2, { color: "cyan", children: [
+                  "/ce_plan ",
+                  /* @__PURE__ */ jsx4(Text2, { color: "dim", children: "- Generate plan" })
+                ] }),
+                /* @__PURE__ */ jsxs(Text2, { color: "cyan", children: [
+                  "/ce_execute ",
+                  /* @__PURE__ */ jsx4(Text2, { color: "dim", children: "- Run executor" })
+                ] })
+              ] })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs(Box2, { marginTop: 1, borderStyle: "single", borderColor: "blue", flexDirection: "column", paddingX: 1, children: [
+            /* @__PURE__ */ jsx4(Text2, { bold: true, color: "blue", children: "Active Tasks" }),
+            activeTasks.length === 0 ? /* @__PURE__ */ jsx4(Box2, { paddingY: 1, children: /* @__PURE__ */ jsx4(Text2, { color: "dim", children: "No tasks currently in progress." }) }) : activeTasks.slice(0, 3).map((t, i) => /* @__PURE__ */ jsxs(Box2, { flexDirection: "column", marginTop: i === 0 ? 0 : 1, children: [
+              /* @__PURE__ */ jsxs(Box2, { children: [
+                /* @__PURE__ */ jsx4(Text2, { color: "yellow", children: "* " }),
+                /* @__PURE__ */ jsx4(Text2, { bold: true, color: "white", children: t.project }),
+                /* @__PURE__ */ jsx4(Text2, { color: "dim", children: ": " }),
+                /* @__PURE__ */ jsx4(Text2, { color: "white", children: t.title })
+              ] }),
+              t.session && /* @__PURE__ */ jsxs(Box2, { marginLeft: 3, children: [
+                /* @__PURE__ */ jsxs(Text2, { children: [
+                  getPhaseIcon(t.session.agent),
+                  " "
+                ] }),
+                /* @__PURE__ */ jsx4(Text2, { color: "cyan", children: t.session.agent }),
+                /* @__PURE__ */ jsx4(Text2, { color: "dim", children: " - " }),
+                /* @__PURE__ */ jsx4(Text2, { color: "white", children: t.session.phase }),
+                /* @__PURE__ */ jsx4(Text2, { color: "dim", children: " - " }),
+                /* @__PURE__ */ jsxs(Text2, { color: "green", children: [
+                  getElapsedTime(t.session.started_at),
+                  " elapsed"
+                ] })
+              ] }),
+              t.todos && t.todos.items.length > 0 && /* @__PURE__ */ jsx4(Box2, { flexDirection: "column", marginLeft: 3, children: t.todos.items.slice(0, 3).map((item, idx) => /* @__PURE__ */ jsxs(Box2, { children: [
+                /* @__PURE__ */ jsxs(Text2, { color: "dim", children: [
+                  getTreeBranch(idx === Math.min(2, t.todos.items.length - 1)),
+                  " "
+                ] }),
+                /* @__PURE__ */ jsx4(Text2, { color: item.status === "completed" ? "green" : item.status === "in_progress" ? "yellow" : "dim", children: getTodoStatusIcon(item.status) }),
+                /* @__PURE__ */ jsxs(Text2, { color: item.status === "completed" ? "dim" : "white", children: [
+                  " ",
+                  item.content.length > 40 ? item.content.substring(0, 37) + "..." : item.content
+                ] })
+              ] }, item.id)) })
+            ] }, `${t.project}-${t.slug}`)),
+            activeTasks.length > 3 && /* @__PURE__ */ jsxs(Text2, { color: "dim", children: [
+              "   ...and ",
+              activeTasks.length - 3,
+              " more"
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs(Box2, { marginTop: 1, borderStyle: "single", borderColor: "dim", flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+            /* @__PURE__ */ jsx4(Text2, { bold: true, color: "dim", children: "Recent Activity" }),
+            /* @__PURE__ */ jsx4(Box2, { flexDirection: "column", marginTop: 0, children: recentLogs.length === 0 ? /* @__PURE__ */ jsx4(Text2, { color: "dim", children: "Waiting for activity..." }) : recentLogs.map((log, i) => /* @__PURE__ */ jsx4(Text2, { color: "white", wrap: "truncate-end", children: log.length > 80 ? log.substring(0, 77) + "..." : log }, i)) })
+          ] }),
+          /* @__PURE__ */ jsxs(Box2, { marginTop: 0, justifyContent: "space-between", children: [
+            /* @__PURE__ */ jsx4(Text2, { color: "dim", children: "r:Restart q:Quit 1-4/arrows:Tabs" }),
+            /* @__PURE__ */ jsx4(Text2, { color: "dim", children: "CE MCP Hub v0.4.0" })
+          ] })
+        ] })
+      ] });
+    });
+  }
+});
+
+// src/ui/views/projects-view.tsx
+import { useState as useState2, memo as memo2 } from "react";
+import { Box as Box3, Text as Text3, useInput } from "ink";
+import { jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+var ProjectsView;
+var init_projects_view = __esm({
+  "src/ui/views/projects-view.tsx"() {
+    "use strict";
+    init_use_config();
+    init_use_services();
+    ProjectsView = memo2(({ config: initialConfig, projects, onConfigChange, workspacePath }) => {
+      const { driftReports, checkAllDrift } = useConfig();
+      const container = useServices();
+      const [config, setConfig] = useState2(initialConfig);
+      const [selectedIndex, setSelectedIndex] = useState2(0);
+      const [selected, setSelected] = useState2(() => {
+        const exposed = /* @__PURE__ */ new Set();
+        for (const p of projects) {
+          if (container.config.isProjectExposed(config, p.name, p.path)) {
+            exposed.add(p.path);
+          }
+        }
+        return exposed;
+      });
+      useInput((input, key) => {
+        if (input === "u") {
+          checkAllDrift();
+          return;
+        }
+        if (key.upArrow) {
+          setSelectedIndex((prev) => Math.max(0, prev - 1));
+          return;
+        }
+        if (key.downArrow) {
+          setSelectedIndex((prev) => Math.min(projects.length - 1, prev + 1));
+          return;
+        }
+        if (input === " ") {
+          const p = projects[selectedIndex];
+          if (!p) return;
+          setSelected((prev) => {
+            const next = new Set(prev);
+            if (next.has(p.path)) next.delete(p.path);
+            else next.add(p.path);
+            return next;
+          });
+          return;
+        }
+        if (key.return) {
+          let newConfig = { ...config };
+          for (const p of projects) {
+            const expose = selected.has(p.path);
+            newConfig = container.config.setProject(newConfig, p.name, expose, void 0, p.path);
+          }
+          container.config.save(newConfig);
+          setConfig(newConfig);
+          onConfigChange?.();
+          return;
+        }
+        if (input === "a") {
+          const newConfig = {
+            ...config,
+            defaults: { ...config.defaults, includeNew: !config.defaults.includeNew }
+          };
+          container.config.save(newConfig);
+          setConfig(newConfig);
+          onConfigChange?.();
+        }
+      });
+      return /* @__PURE__ */ jsxs2(Box3, { flexDirection: "column", borderStyle: "round", borderColor: "white", flexGrow: 1, children: [
+        /* @__PURE__ */ jsxs2(Box3, { paddingX: 1, justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsxs2(Box3, { children: [
+            /* @__PURE__ */ jsx5(Text3, { bold: true, color: "cyan", children: "Projects" }),
+            /* @__PURE__ */ jsx5(Text3, { color: "dim", children: " | " }),
+            /* @__PURE__ */ jsxs2(Text3, { color: config.defaults.includeNew ? "green" : "red", children: [
+              "Auto-expose: ",
+              config.defaults.includeNew ? "ON" : "OFF"
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx5(Text3, { color: "dim", children: "v0.4.0" })
+        ] }),
+        /* @__PURE__ */ jsx5(Box3, { marginTop: 1, paddingX: 1, children: /* @__PURE__ */ jsx5(Text3, { color: "dim", children: "Manage which projects are exposed to the MCP server." }) }),
+        /* @__PURE__ */ jsx5(Box3, { marginTop: 1, paddingX: 1, flexDirection: "column", flexGrow: 1, children: projects.map((p, i) => {
+          const isActive = i === selectedIndex;
+          const isChecked = selected.has(p.path);
+          const isCurrent = p.path === workspacePath;
+          const drift = driftReports[p.path];
+          return /* @__PURE__ */ jsxs2(Box3, { children: [
+            /* @__PURE__ */ jsx5(Text3, { color: isActive ? "cyan" : "white", children: isActive ? "> " : "  " }),
+            /* @__PURE__ */ jsx5(Text3, { color: isChecked ? "green" : "gray", children: isChecked ? "[x] " : "[ ] " }),
+            /* @__PURE__ */ jsx5(Text3, { color: isActive ? "cyan" : "white", children: p.name }),
+            isCurrent && /* @__PURE__ */ jsx5(Text3, { color: "yellow", children: " (current)" }),
+            drift?.hasDrift && /* @__PURE__ */ jsx5(Text3, { color: "magenta", children: " !" })
+          ] }, p.path);
+        }) }),
+        /* @__PURE__ */ jsxs2(Box3, { paddingX: 1, justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsx5(Text3, { color: "dim", children: "Space:Select  Enter:Save  a:Toggle Auto  u:Refresh Drift" }),
+          /* @__PURE__ */ jsx5(Text3, { color: "dim", children: "q to exit" })
+        ] })
+      ] });
+    });
+  }
+});
+
+// src/ui/hooks/use-tasks.ts
+import { useState as useState3, useCallback as useCallback2, useMemo as useMemo4 } from "react";
+function useTasks(projects) {
+  const container = useServices();
+  const [taskCache, setTaskCache] = useState3({});
+  const refreshForProject = useCallback2((project) => {
+    const tasks = container.tasks.list(project.name);
+    setTaskCache((prev) => ({ ...prev, [project.name]: tasks }));
+  }, [container]);
+  const refreshAll = useCallback2(() => {
+    const next = {};
+    for (const p of projects) {
+      next[p.name] = container.tasks.list(p.name);
+    }
+    setTaskCache(next);
+  }, [projects, container]);
+  const totalCount = useMemo4(
+    () => Object.values(taskCache).reduce((sum, tasks) => sum + tasks.length, 0),
+    [taskCache]
+  );
+  return { taskCache, refreshForProject, refreshAll, totalCount };
+}
+var init_use_tasks = __esm({
+  "src/ui/hooks/use-tasks.ts"() {
+    "use strict";
+    init_use_services();
+  }
+});
+
+// src/ui/components/task-row.tsx
+import "react";
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+function getActiveAgent(task) {
+  const agents = task.agents;
+  if (!agents) return null;
+  for (const [agent, info] of Object.entries(agents)) {
+    if (info?.status === "in_progress") return { agent, status: "in_progress" };
+  }
+  const order = ["documentation", "executor", "planning", "research"];
+  for (const agent of order) {
+    if (agents[agent]?.status === "complete") return { agent, status: "complete" };
+  }
+  return null;
+}
+var TaskRow;
+var init_task_row = __esm({
+  "src/ui/components/task-row.tsx"() {
+    "use strict";
+    init_ui_helpers();
+    TaskRow = ({
+      row,
+      isSelected,
+      isExpanded,
+      taskCount,
+      hasDrift,
+      isCurrentProject = false,
+      isLastTask = false
+    }) => {
+      if (row.kind === "project") {
+        const projectColor = isSelected ? "cyan" : isCurrentProject ? "yellow" : "white";
+        return /* @__PURE__ */ jsxs3(Box4, { children: [
+          /* @__PURE__ */ jsx6(Text4, { color: isSelected ? "cyan" : "dim", children: isSelected ? "\u25B8 " : "  " }),
+          /* @__PURE__ */ jsxs3(Text4, { bold: isSelected || isCurrentProject, color: projectColor, children: [
+            getFolderIcon(isExpanded),
+            " ",
+            row.project.name
+          ] }),
+          isCurrentProject && /* @__PURE__ */ jsx6(Text4, { color: "yellow", dimColor: true, children: " (current)" }),
+          hasDrift && /* @__PURE__ */ jsx6(Text4, { color: "magenta", children: " \u26A0" }),
+          /* @__PURE__ */ jsx6(Text4, { color: "dim", children: taskCount > 0 ? ` [${taskCount}]` : "" })
+        ] });
+      }
+      const { task } = row;
+      const branch = getTreeBranch(isLastTask);
+      const isPlaceholder = task.task_slug === "__none__";
+      if (isPlaceholder) {
+        return /* @__PURE__ */ jsxs3(Box4, { children: [
+          /* @__PURE__ */ jsxs3(Text4, { color: "dim", children: [
+            "  ",
+            branch,
+            " "
+          ] }),
+          /* @__PURE__ */ jsx6(Text4, { color: "dim", italic: true, children: task.title })
+        ] });
+      }
+      const activeAgent = getActiveAgent(task);
+      const progress = getChecklistProgress(task.checklist || []);
+      const relativeTime = task.updated_at ? formatRelativeTime(task.updated_at) : "";
+      return /* @__PURE__ */ jsxs3(Box4, { children: [
+        /* @__PURE__ */ jsx6(Text4, { color: isSelected ? "cyan" : "dim", children: isSelected ? "\u25B8 " : "  " }),
+        /* @__PURE__ */ jsxs3(Text4, { color: "dim", children: [
+          branch,
+          " "
+        ] }),
+        /* @__PURE__ */ jsx6(Text4, { color: isSelected ? "cyan" : "white", children: "\u{1F4CB} " }),
+        /* @__PURE__ */ jsx6(Box4, { flexGrow: 1, children: /* @__PURE__ */ jsx6(Text4, { bold: isSelected, color: isSelected ? "cyan" : "white", children: task.title.length > 25 ? task.title.substring(0, 22) + "..." : task.title }) }),
+        activeAgent && /* @__PURE__ */ jsxs3(Text4, { children: [
+          /* @__PURE__ */ jsx6(Text4, { color: "dim", children: " " }),
+          /* @__PURE__ */ jsx6(Text4, { children: getPhaseIcon(activeAgent.agent) }),
+          /* @__PURE__ */ jsx6(Text4, { color: activeAgent.status === "in_progress" ? "yellow" : "green", children: getAgentStatusIcon(activeAgent.status) })
+        ] }),
+        progress.total > 0 && /* @__PURE__ */ jsxs3(Text4, { color: "dim", children: [
+          " ",
+          getProgressBar(progress.percentage, 6),
+          " ",
+          progress.completed,
+          "/",
+          progress.total
+        ] }),
+        relativeTime && relativeTime !== "\u2014" && /* @__PURE__ */ jsxs3(Text4, { color: "dim", children: [
+          " ",
+          relativeTime
+        ] }),
+        !activeAgent && task.status && /* @__PURE__ */ jsxs3(Text4, { color: getStatusColor(task.status), children: [
+          " ",
+          getStatusIcon(task.status),
+          " ",
+          task.status
+        ] })
+      ] });
+    };
+  }
+});
+
+// src/ui/components/task-tree.tsx
+import "react";
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
+var TaskTree;
+var init_task_tree = __esm({
+  "src/ui/components/task-tree.tsx"() {
+    "use strict";
+    init_task_row();
+    TaskTree = ({
+      flattenedRows,
+      selectedIndex,
+      expanded,
+      taskCache,
+      driftReports
+    }) => /* @__PURE__ */ jsx7(Box5, { flexDirection: "column", width: "50%", borderStyle: "single", borderColor: "dim", borderRight: true, paddingX: 1, children: flattenedRows.length === 0 ? /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", alignItems: "center", justifyContent: "center", flexGrow: 1, children: [
+      /* @__PURE__ */ jsx7(Text5, { color: "dim", children: "No projects detected." }),
+      /* @__PURE__ */ jsx7(Text5, { color: "dim", children: "Run the wizard to set up projects." })
+    ] }) : /* @__PURE__ */ jsx7(Box5, { flexDirection: "column", marginTop: 1, children: flattenedRows.map((row, idx) => {
+      const key = row.project.name;
+      return /* @__PURE__ */ jsx7(
+        TaskRow,
+        {
+          row,
+          isSelected: idx === selectedIndex,
+          isExpanded: expanded.has(key),
+          taskCount: (taskCache[key] || []).length,
+          hasDrift: !!driftReports[row.project.path]?.hasDrift,
+          isCurrentProject: row.kind === "project" ? row.isCurrentProject : false,
+          isLastTask: row.kind === "task" ? row.isLastTask : false
+        },
+        row.kind === "project" ? `p:${key}` : `t:${key}:${row.task.task_slug}`
+      );
+    }) }) });
+  }
+});
+
+// src/ui/views/tasks-view.tsx
+import { useEffect as useEffect2, useMemo as useMemo5, useState as useState4, memo as memo3 } from "react";
+import { Box as Box6, Text as Text6, useInput as useInput2 } from "ink";
+import { jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
+function nextStatus(current) {
+  const idx = STATUS_CYCLE.indexOf(current);
+  if (idx === -1) return STATUS_CYCLE[0];
+  return STATUS_CYCLE[(idx + 1) % STATUS_CYCLE.length];
+}
+var STATUS_CYCLE, TasksView, TaskDetailsPane;
+var init_tasks_view = __esm({
+  "src/ui/views/tasks-view.tsx"() {
+    "use strict";
+    init_use_config();
+    init_use_tasks();
+    init_use_services();
+    init_task_tree();
+    init_ui_helpers();
+    STATUS_CYCLE = ["pending", "in_progress", "blocked", "complete"];
+    TasksView = memo3(({ projects, workspacePath }) => {
+      const { driftReports } = useConfig();
+      const container = useServices();
+      const { taskCache, refreshForProject, refreshAll, totalCount } = useTasks(projects);
+      const [expanded, setExpanded] = useState4(() => /* @__PURE__ */ new Set());
+      const [selectedIndex, setSelectedIndex] = useState4(0);
+      const [errorLine, setErrorLine] = useState4(null);
+      useEffect2(() => {
+        const current = projects.find((p) => p.path === workspacePath);
+        if (current && !expanded.has(current.name)) {
+          setExpanded((prev) => {
+            const next = new Set(prev);
+            next.add(current.name);
+            return next;
+          });
+          refreshForProject(current);
+        }
+      }, [projects, workspacePath]);
+      const flattenedRows = useMemo5(() => {
+        const rows = [];
+        for (const p of projects) {
+          const isCurrentProject = p.path === workspacePath;
+          rows.push({ kind: "project", project: p, isCurrentProject });
+          if (!expanded.has(p.name)) continue;
+          const tasks = taskCache[p.name] || [];
+          tasks.forEach((t, idx) => {
+            rows.push({ kind: "task", project: p, task: t, isLastTask: idx === tasks.length - 1 });
+          });
+          if (tasks.length === 0) {
+            rows.push({
+              kind: "task",
+              project: p,
+              task: { task_slug: "__none__", title: "(no tasks)", summary: "", status: "", created_at: "", updated_at: "" },
+              isLastTask: true
+            });
+          }
+        }
+        return rows;
+      }, [projects, expanded, taskCache, workspacePath]);
+      useInput2((input, key) => {
+        if (input === "R") {
+          setErrorLine(null);
+          refreshAll();
+          return;
+        }
+        if (key.upArrow) {
+          setSelectedIndex((prev) => Math.max(0, prev - 1));
+          return;
+        }
+        if (key.downArrow) {
+          setSelectedIndex((prev) => Math.min(flattenedRows.length - 1, prev + 1));
+          return;
+        }
+        if (key.return) {
+          const row = flattenedRows[selectedIndex];
+          if (row?.kind === "project") {
+            const next = new Set(expanded);
+            if (next.has(row.project.name)) {
+              next.delete(row.project.name);
+            } else {
+              next.add(row.project.name);
+              refreshForProject(row.project);
+            }
+            setExpanded(next);
+          }
+          return;
+        }
+        if (input === "s") {
+          const row = flattenedRows[selectedIndex];
+          if (row?.kind === "task" && row.task.task_slug !== "__none__") {
+            setErrorLine(null);
+            const desired = nextStatus(row.task.status);
+            const result = container.tasks.update(row.project.name, row.task.task_slug, { status: desired });
+            if (!result) {
+              setErrorLine("Failed to update status");
+              return;
+            }
+            refreshForProject(row.project);
+          }
+        }
+      });
+      useEffect2(() => {
+        setSelectedIndex((prev) => Math.min(prev, Math.max(0, flattenedRows.length - 1)));
+      }, [flattenedRows]);
+      const selectedRow = flattenedRows[selectedIndex];
+      const selectedTask = selectedRow?.kind === "task" && selectedRow.task.task_slug !== "__none__" ? selectedRow.task : null;
+      return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "white", flexGrow: 1, children: [
+        /* @__PURE__ */ jsxs5(Box6, { paddingX: 1, justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsxs5(Box6, { children: [
+            /* @__PURE__ */ jsx8(Text6, { bold: true, color: "cyan", children: "Tasks" }),
+            /* @__PURE__ */ jsx8(Text6, { color: "dim", children: " | " }),
+            /* @__PURE__ */ jsxs5(Text6, { children: [
+              projects.length,
+              " projects"
+            ] }),
+            /* @__PURE__ */ jsx8(Text6, { color: "dim", children: " - " }),
+            /* @__PURE__ */ jsxs5(Text6, { children: [
+              totalCount,
+              " tasks"
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx8(Text6, { color: "dim", children: "v0.4.0" })
+        ] }),
+        errorLine && /* @__PURE__ */ jsx8(Box6, { paddingX: 1, marginTop: 1, children: /* @__PURE__ */ jsxs5(Text6, { color: "red", children: [
+          "! ",
+          errorLine
+        ] }) }),
+        /* @__PURE__ */ jsxs5(Box6, { flexDirection: "row", flexGrow: 1, children: [
+          /* @__PURE__ */ jsx8(
+            TaskTree,
+            {
+              flattenedRows,
+              selectedIndex,
+              expanded,
+              taskCache,
+              driftReports
+            }
+          ),
+          /* @__PURE__ */ jsx8(Box6, { flexDirection: "column", width: "50%", paddingX: 1, marginTop: 1, children: /* @__PURE__ */ jsx8(TaskDetailsPane, { task: selectedTask }) })
+        ] }),
+        /* @__PURE__ */ jsxs5(Box6, { paddingX: 1, justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsx8(Text6, { color: "dim", children: "Up/Down:Nav  Enter:Expand  s:Cycle Status  R:Refresh" }),
+          /* @__PURE__ */ jsx8(Text6, { color: "dim", children: "q to exit" })
+        ] })
+      ] });
+    });
+    TaskDetailsPane = ({ task }) => {
+      if (!task) {
+        return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", justifyContent: "center", alignItems: "center", flexGrow: 1, children: [
+          /* @__PURE__ */ jsx8(Text6, { bold: true, color: "dim", children: "No Task Selected" }),
+          /* @__PURE__ */ jsx8(Text6, { color: "dim", children: "Use arrows to navigate" })
+        ] });
+      }
+      const checklist = task.checklist || [];
+      const progress = getChecklistProgress(checklist);
+      return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx8(Text6, { bold: true, color: "cyan", children: task.title || task.task_slug }),
+        task.summary && /* @__PURE__ */ jsx8(Text6, { color: "white", wrap: "wrap", children: task.summary.length > 150 ? task.summary.substring(0, 147) + "..." : task.summary }),
+        /* @__PURE__ */ jsx8(Box6, { marginY: 0, children: /* @__PURE__ */ jsx8(Text6, { color: "dim", children: "\u2500".repeat(40) }) }),
+        /* @__PURE__ */ jsxs5(Box6, { justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsx8(Text6, { bold: true, color: "white", children: "STATUS" }),
+          /* @__PURE__ */ jsx8(Text6, { color: getStatusColor(task.status || ""), children: task.status?.toUpperCase() || "UNKNOWN" })
+        ] }),
+        /* @__PURE__ */ jsxs5(Box6, { marginLeft: 1, children: [
+          /* @__PURE__ */ jsx8(Text6, { color: "dim", children: "Updated: " }),
+          /* @__PURE__ */ jsx8(Text6, { children: formatRelativeTime(task.updated_at || "") })
+        ] }),
+        /* @__PURE__ */ jsx8(Box6, { marginY: 0, children: /* @__PURE__ */ jsx8(Text6, { color: "dim", children: "\u2500".repeat(40) }) }),
+        /* @__PURE__ */ jsxs5(Text6, { bold: true, color: "white", children: [
+          "CHECKLIST ",
+          progress.total > 0 && `${getProgressBar(progress.percentage, 8)} ${progress.completed}/${progress.total}`
+        ] }),
+        /* @__PURE__ */ jsx8(Box6, { flexDirection: "column", marginLeft: 1, children: checklist.length === 0 ? /* @__PURE__ */ jsx8(Text6, { color: "dim", children: "No checklist items" }) : checklist.slice(0, 10).map((c, i) => /* @__PURE__ */ jsxs5(Text6, { color: c.status === "done" ? "dim" : "white", children: [
+          /* @__PURE__ */ jsxs5(Text6, { color: c.status === "done" ? "green" : "dim", children: [
+            getCheckbox(c.status || "pending"),
+            " "
+          ] }),
+          (c.label || c.id || "item").substring(0, 40)
+        ] }, c.id || i)) }),
+        /* @__PURE__ */ jsx8(Box6, { marginY: 0, children: /* @__PURE__ */ jsx8(Text6, { color: "dim", children: "\u2500".repeat(40) }) }),
+        /* @__PURE__ */ jsx8(Text6, { bold: true, color: "white", children: "AGENTS" }),
+        /* @__PURE__ */ jsx8(Box6, { flexDirection: "column", marginLeft: 1, children: (() => {
+          const agents = task.agents;
+          if (!agents || Object.keys(agents).length === 0) {
+            return /* @__PURE__ */ jsx8(Text6, { color: "dim", children: "No agent activity yet" });
+          }
+          return Object.entries(agents).map(([agent, info]) => /* @__PURE__ */ jsxs5(Box6, { children: [
+            /* @__PURE__ */ jsxs5(Text6, { children: [
+              getPhaseIcon(agent),
+              " "
+            ] }),
+            /* @__PURE__ */ jsxs5(Text6, { color: "dim", children: [
+              agent,
+              ": "
+            ] }),
+            /* @__PURE__ */ jsx8(Text6, { color: info?.status === "complete" ? "dim" : "white", children: info?.status || "pending" })
+          ] }, agent));
+        })() })
+      ] });
+    };
+  }
+});
+
+// src/ui/views/log-viewer.tsx
+import { memo as memo4 } from "react";
+import { Box as Box7, Text as Text7 } from "ink";
+import { jsx as jsx9, jsxs as jsxs6 } from "react/jsx-runtime";
+var formatLog, LogViewer;
+var init_log_viewer = __esm({
+  "src/ui/views/log-viewer.tsx"() {
+    "use strict";
+    formatLog = (log) => {
+      if (log.includes("[ERROR]")) return /* @__PURE__ */ jsx9(Text7, { color: "red", children: log });
+      if (log.includes("[WARN]")) return /* @__PURE__ */ jsx9(Text7, { color: "yellow", children: log });
+      if (log.includes("[INFO]")) return /* @__PURE__ */ jsx9(Text7, { color: "green", children: log });
+      if (log.includes("[RAG]")) return /* @__PURE__ */ jsx9(Text7, { color: "cyan", children: log });
+      return /* @__PURE__ */ jsx9(Text7, { children: log });
+    };
+    LogViewer = memo4(({ logs, height }) => {
+      const visibleLogs = logs.slice(-height);
+      const emptyLines = Math.max(0, height - visibleLogs.length);
+      return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", borderStyle: "round", borderColor: "white", paddingX: 1, height: height + 2, flexGrow: 1, children: [
+        Array.from({ length: emptyLines }, (_, i) => /* @__PURE__ */ jsx9(Text7, { children: " " }, `empty-${i}`)),
+        visibleLogs.map((log, i) => /* @__PURE__ */ jsx9(Box7, { children: formatLog(log) }, `log-${i}`))
+      ] });
+    });
+  }
+});
+
+// src/ui/components/status-bar.tsx
+import "react";
+import { Box as Box8, Text as Text8 } from "ink";
+import { jsx as jsx10, jsxs as jsxs7 } from "react/jsx-runtime";
+var StatusBar;
+var init_status_bar = __esm({
+  "src/ui/components/status-bar.tsx"() {
+    "use strict";
+    StatusBar = ({ exposedLabel, port, pid, running, hasDrift }) => /* @__PURE__ */ jsx10(Box8, { borderStyle: "single", borderColor: "white", paddingX: 1, flexGrow: 1, children: /* @__PURE__ */ jsxs7(Text8, { children: [
+      running ? /* @__PURE__ */ jsx10(Text8, { color: "green", children: "\u25CF RUNNING" }) : /* @__PURE__ */ jsx10(Text8, { color: "red", children: "\u25CF STOPPED" }),
+      " \u2502 \u{1F4CB} ",
+      /* @__PURE__ */ jsx10(Text8, { color: "yellow", children: exposedLabel }),
+      " \u2502 Port: ",
+      /* @__PURE__ */ jsx10(Text8, { color: "green", children: port }),
+      " \u2502 PID: ",
+      /* @__PURE__ */ jsx10(Text8, { color: "green", children: pid }),
+      hasDrift && /* @__PURE__ */ jsx10(Text8, { color: "magenta", bold: true, children: " \u2502 UPDATE AVAILABLE" })
+    ] }) });
+  }
+});
+
+// src/ui/components/tab-bar.tsx
+import "react";
+import { Box as Box9, Text as Text9, useInput as useInput3 } from "ink";
+import { jsx as jsx11, jsxs as jsxs8 } from "react/jsx-runtime";
+var TabBar;
+var init_tab_bar = __esm({
+  "src/ui/components/tab-bar.tsx"() {
+    "use strict";
+    TabBar = ({ tabs, activeTab, onChange }) => {
+      useInput3((input, key) => {
+        if (tabs.length === 0) return;
+        if (key.leftArrow) {
+          const index = tabs.findIndex((t) => t.id === activeTab);
+          if (index !== -1) {
+            const next = tabs[(index - 1 + tabs.length) % tabs.length];
+            if (next) onChange(next.id);
+          }
+        }
+        if (key.rightArrow) {
+          const index = tabs.findIndex((t) => t.id === activeTab);
+          if (index !== -1) {
+            const next = tabs[(index + 1) % tabs.length];
+            if (next) onChange(next.id);
+          }
+        }
+        const num = parseInt(input);
+        if (!isNaN(num) && num > 0 && num <= tabs.length) {
+          const tab = tabs[num - 1];
+          if (tab) onChange(tab.id);
+        }
+      });
+      return /* @__PURE__ */ jsxs8(Box9, { borderStyle: "single", paddingX: 1, borderColor: "gray", children: [
+        tabs.map((tab) => {
+          const isActive = tab.id === activeTab;
+          return /* @__PURE__ */ jsx11(Box9, { marginRight: 2, children: /* @__PURE__ */ jsx11(Text9, { color: isActive ? "cyan" : "white", bold: isActive, children: isActive ? `[ ${tab.label} ]` : `  ${tab.label}  ` }) }, tab.id);
+        }),
+        /* @__PURE__ */ jsx11(Box9, { flexGrow: 1 }),
+        /* @__PURE__ */ jsx11(Text9, { color: "dim", children: "Use arrow keys to navigate" })
+      ] });
+    };
+  }
+});
+
+// src/ui/hooks/use-log-stream.ts
+import { useState as useState5, useEffect as useEffect3 } from "react";
+function useLogStream(logger, maxLines = 100) {
+  const [logs, setLogs] = useState5([]);
+  useEffect3(() => {
+    const handler = (line) => {
+      setLogs((prev) => {
+        const next = [...prev, line];
+        return next.length > maxLines ? next.slice(-maxLines) : next;
+      });
+    };
+    logger.on("line", handler);
+    return () => {
+      logger.off("line", handler);
+    };
+  }, [logger, maxLines]);
+  return logs;
+}
+var init_use_log_stream = __esm({
+  "src/ui/hooks/use-log-stream.ts"() {
+    "use strict";
+  }
+});
+
+// src/ui/app.tsx
+import { useState as useState6, useMemo as useMemo6, useCallback as useCallback3, memo as memo5 } from "react";
+import { Box as Box10, useInput as useInput4, useApp } from "ink";
+import { jsx as jsx12, jsxs as jsxs9 } from "react/jsx-runtime";
+var App;
+var init_app = __esm({
+  "src/ui/app.tsx"() {
+    "use strict";
+    init_overview();
+    init_projects_view();
+    init_tasks_view();
+    init_log_viewer();
+    init_status_bar();
+    init_tab_bar();
+    init_use_config();
+    init_use_services();
+    init_use_log_stream();
+    init_server();
+    init_paths();
+    App = memo5(({ onExit, initialPort }) => {
+      const { exit } = useApp();
+      const { config, projects, exposedProjects, driftReports, refresh: refreshData } = useConfig();
+      const container = useServices();
+      const logs = useLogStream(container.logger);
+      const [activeTab, setActiveTab] = useState6("overview");
+      const [serverInfo, setServerInfo] = useState6({
+        port: initialPort,
+        pid: process.pid,
+        running: true
+        // Server started before rendering
+      });
+      const workspacePath = useMemo6(() => detectWorkspaceRoot(), []);
+      const hasAnyDrift = useMemo6(
+        () => Object.values(driftReports).some((r) => r.hasDrift),
+        [driftReports]
+      );
+      const tabs = useMemo6(() => [
+        { id: "overview", label: "Overview" },
+        { id: "logs", label: "Logs" },
+        { id: "tasks", label: "Tasks" },
+        { id: "projects", label: "Projects" }
+      ], []);
+      useInput4((input, key) => {
+        if (input === "q" || key.ctrl && input === "c") {
+          onExit();
+          exit();
+        }
+      });
+      const termHeight = process.stdout.rows || 24;
+      const contentHeight = termHeight - 8;
+      const handleConfigChange = useCallback3(() => {
+        refreshData();
+      }, [refreshData]);
+      return /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", padding: 0, height: termHeight, children: [
+        /* @__PURE__ */ jsx12(TabBar, { tabs, activeTab, onChange: setActiveTab }),
+        /* @__PURE__ */ jsxs9(Box10, { marginTop: 1, flexGrow: 1, children: [
+          activeTab === "overview" && /* @__PURE__ */ jsx12(
+            Overview,
+            {
+              serverStatus: serverInfo,
+              stats: {
+                exposedProjects: exposedProjects.length,
+                totalProjects: projects.length
+              },
+              logs
+            }
+          ),
+          activeTab === "logs" && /* @__PURE__ */ jsx12(LogViewer, { logs, height: contentHeight }),
+          activeTab === "tasks" && /* @__PURE__ */ jsx12(TasksView, { projects, workspacePath }),
+          activeTab === "projects" && /* @__PURE__ */ jsx12(ProjectsView, { config, projects, onConfigChange: handleConfigChange, workspacePath })
+        ] }),
+        /* @__PURE__ */ jsx12(Box10, { marginTop: 0, children: /* @__PURE__ */ jsx12(
+          StatusBar,
+          {
+            exposedLabel: `${exposedProjects.length} / ${projects.length} projects`,
+            port: serverInfo.port,
+            pid: serverInfo.pid,
+            running: serverInfo.running,
+            hasDrift: hasAnyDrift
+          }
+        ) })
+      ] });
+    });
+  }
+});
+
+// src/ui/index.ts
+var ui_exports = {};
+__export(ui_exports, {
+  startTUI: () => startTUI
+});
+import React13 from "react";
+import { render } from "ink";
+async function startTUI(container) {
+  const config = container.config.load();
+  const port = config.server.port;
+  const server = new MCPServer(container);
+  await server.start({ interactive: true });
+  process.stdin.resume();
+  const app = render(
+    React13.createElement(
+      ServiceProvider,
+      { container },
+      React13.createElement(
+        ConfigProvider,
+        null,
+        React13.createElement(App, {
+          initialPort: port,
+          onExit: () => {
+            server.stop();
+          }
+        })
+      )
+    ),
+    { exitOnCtrlC: false }
+  );
+  await app.waitUntilExit();
+  console.clear();
+}
+var init_ui = __esm({
+  "src/ui/index.ts"() {
+    "use strict";
+    init_app();
+    init_service_provider();
+    init_config_provider();
+    init_server();
+  }
+});
+
+// src/commands/wizard/index.ts
+var wizard_exports = {};
+__export(wizard_exports, {
+  runWizard: () => runWizard
+});
+import * as readline from "readline";
+function createRL() {
+  return readline.createInterface({ input: process.stdin, output: process.stdout });
+}
+function ask(rl, question) {
+  return new Promise((resolve3) => rl.question(question, resolve3));
+}
+function confirm(rl, question, defaultVal = true) {
+  return new Promise((resolve3) => {
+    const hint = defaultVal ? "[Y/n]" : "[y/N]";
+    rl.question(`${question} ${hint} `, (answer) => {
+      if (answer.trim() === "") resolve3(defaultVal);
+      else resolve3(answer.trim().toLowerCase().startsWith("y"));
+    });
+  });
+}
+async function runWizard() {
+  const rl = createRL();
+  console.log("\n  CE-Workflow Setup Wizard\n");
+  console.log("  Set up your workspace for agentic code workflows.\n");
+  const container = createServices();
+  const workspaceRoot = detectWorkspaceRoot();
+  const workspaceName = getWorkspaceName(workspaceRoot);
+  console.log(`  Workspace: ${workspaceName} (${workspaceRoot})`);
+  const home = getHome();
+  ensureDir(home);
+  console.log(`  Storage:   ${home}
+`);
+  const shouldRegister = await confirm(rl, "  Register this project?");
+  if (shouldRegister) {
+    const config = container.config.load();
+    container.config.setProject(config, workspaceName, true, void 0, workspaceRoot);
+    container.config.save(config);
+    console.log(`  -> Project "${workspaceName}" registered and exposed.
+`);
+  }
+  const enableSearch = await confirm(rl, "  Enable semantic search (Local RAG)?");
+  if (enableSearch) {
+    const config = container.config.load();
+    container.config.setProject(config, workspaceName, true, void 0, workspaceRoot, { enabled: true });
+    container.config.save(config);
+    console.log("  -> Semantic search enabled. First use will download the embedding model.\n");
+  }
+  const portAnswer = await ask(rl, "  MCP server port [3200]: ");
+  const port = parseInt(portAnswer.trim(), 10);
+  if (!isNaN(port) && port > 0) {
+    const config = container.config.load();
+    config.server.port = port;
+    container.config.save(config);
+    console.log(`  -> Port set to ${port}
+`);
+  }
+  const shouldStart = await confirm(rl, "  Start the MCP dashboard now?");
+  rl.close();
+  if (shouldStart) {
+    console.log("  Starting MCP dashboard...\n");
+    const { startTUI: startTUI2 } = await Promise.resolve().then(() => (init_ui(), ui_exports));
+    await startTUI2(container);
+  } else {
+    console.log('\n  Setup complete! Run "ce-workflow mcp" to start the dashboard.\n');
+  }
+}
+var init_wizard = __esm({
+  "src/commands/wizard/index.ts"() {
+    "use strict";
+    init_services();
+    init_paths();
+  }
+});
+
+// src/mcp/index.ts
+init_services();
+init_server();
+init_server();
+init_registry();
+async function runMCP(subcommand2) {
+  const container = createServices();
+  if (subcommand2 === "start" || !process.stdout.isTTY) {
+    const server = new MCPServer(container);
+    await server.start({ interactive: false });
+    await new Promise(() => {
+    });
+    return;
+  }
+  const { startTUI: startTUI2 } = await Promise.resolve().then(() => (init_ui(), ui_exports));
+  await startTUI2(container);
+}
+
+// src/index.ts
+var command = process.argv[2];
+var subcommand = process.argv[3];
+if (!command || command === "wizard" || command === "install") {
+  Promise.resolve().then(() => (init_wizard(), wizard_exports)).then((m) => m.runWizard());
+} else if (command === "mcp") {
+  runMCP(subcommand);
+} else {
+  console.error(`Unknown command: ${command}`);
+  console.error("Usage: ce-workflow [wizard|install|mcp]");
+  process.exit(1);
+}