@stackmemoryai/stackmemory 1.2.2 → 1.2.6

package/dist/src/integrations/linear/sync.js

@@ -5,7 +5,6 @@ const __dirname = __pathDirname(__filename);
 import { readFileSync, writeFileSync, existsSync } from "fs";
 import { join } from "path";
 import { logger } from "../../core/monitoring/logger.js";
-import { IntegrationError, ErrorCode } from "../../core/errors/index.js";
 import { LinearClient } from "./client.js";
 class LinearSyncEngine {
   taskStore;
@@ -15,6 +14,7 @@ class LinearSyncEngine {
   mappings = /* @__PURE__ */ new Map();
   projectRoot;
   mappingsPath;
+  _isConfigured = true;
   constructor(taskStore, authManager, config, projectRoot) {
     this.taskStore = taskStore;
     this.authManager = authManager;
@@ -33,10 +33,9 @@ class LinearSyncEngine {
     } else {
       const tokens = this.authManager.loadTokens();
       if (!tokens) {
-        throw new IntegrationError(
-          'Linear API key or authentication tokens not found. Set LINEAR_API_KEY environment variable or run "stackmemory linear setup" first.',
-          ErrorCode.LINEAR_SYNC_FAILED
-        );
+        logger.info("Linear API key not configured \u2014 skipping Linear sync");
+        this._isConfigured = false;
+        return;
       }
       this.linearClient = new LinearClient({
         apiKey: tokens.accessToken,
@@ -49,6 +48,12 @@ class LinearSyncEngine {
     }
     this.loadMappings();
   }
+  /**
+   * Check if Linear credentials are available
+   */
+  get isConfigured() {
+    return this._isConfigured;
+  }
   /**
    * Update sync configuration
    */
@@ -59,6 +64,14 @@ class LinearSyncEngine {
    * Perform bi-directional sync
    */
   async sync() {
+    if (!this._isConfigured) {
+      return {
+        success: true,
+        synced: { toLinear: 0, fromLinear: 0, updated: 0 },
+        conflicts: [],
+        errors: []
+      };
+    }
     if (!this.config.enabled) {
       return {
         success: false,

package/dist/src/integrations/linear/webhook.js

@@ -22,7 +22,6 @@ function getOptionalEnv(key) {
 class LinearWebhookHandler {
   syncEngine;
   taskStore;
-  graphitiBridge;
   webhookSecret;
   constructor(webhookSecret) {
     this.webhookSecret = webhookSecret || process.env["LINEAR_WEBHOOK_SECRET"];
@@ -39,12 +38,6 @@ class LinearWebhookHandler {
   setTaskStore(taskStore) {
     this.taskStore = taskStore;
   }
-  /**
-   * Set the Graphiti bridge for knowledge graph sync
-   */
-  setGraphitiBridge(bridge) {
-    this.graphitiBridge = bridge;
-  }
   /**
    * Verify webhook signature
    */
@@ -111,15 +104,6 @@ class LinearWebhookHandler {
       default:
         logger.warn(`Unknown webhook action: ${payload.action}`);
     }
-    if (this.graphitiBridge) {
-      this.graphitiBridge.processWebhook(payload).catch((err) => {
-        logger.debug("Linear-Graphiti bridge error", {
-          action: payload.action,
-          identifier: payload.data.identifier,
-          error: err instanceof Error ? err.message : String(err)
-        });
-      });
-    }
   }
   /**
    * Handle issue created in Linear

package/dist/src/integrations/mcp/handlers/code-execution-handlers.js

@@ -27,7 +27,12 @@ class CodeExecutionHandler {
    * Execute code in a controlled environment
    */
   async executeCode(params) {
-    const { language, code, workingDirectory, timeout = EXECUTION_TIMEOUT } = params;
+    const {
+      language,
+      code,
+      workingDirectory,
+      timeout = EXECUTION_TIMEOUT
+    } = params;
     if (!this.allowedLanguages.includes(language.toLowerCase())) {
       return {
         success: false,
@@ -43,7 +48,12 @@ class CodeExecutionHandler {
     );
     try {
       await fs.writeFile(tempFile, code, "utf-8");
-      const result = await this.runCode(language, tempFile, workingDirectory || this.sandboxDir, timeout);
+      const result = await this.runCode(
+        language,
+        tempFile,
+        workingDirectory || this.sandboxDir,
+        timeout
+      );
       await fs.unlink(tempFile).catch(() => {
       });
       return result;
@@ -98,8 +108,15 @@ class CodeExecutionHandler {
         clearTimeout(timeoutId);
         let outputFile;
         if (truncated) {
-          outputFile = join(this.sandboxDir, `output_${randomBytes(8).toString("hex")}.txt`);
-          await fs.writeFile(outputFile, stdout + "\n---STDERR---\n" + stderr, "utf-8").catch(() => {
+          outputFile = join(
+            this.sandboxDir,
+            `output_${randomBytes(8).toString("hex")}.txt`
+          );
+          await fs.writeFile(
+            outputFile,
+            stdout + "\n---STDERR---\n" + stderr,
+            "utf-8"
+          ).catch(() => {
           });
         }
         resolve({
@@ -175,12 +192,21 @@ class CodeExecutionHandler {
     const warnings = [];
     const dangerousPatterns = [
       { pattern: /import\s+os/i, message: "Importing os module detected" },
-      { pattern: /import\s+subprocess/i, message: "Subprocess module detected" },
+      {
+        pattern: /import\s+subprocess/i,
+        message: "Subprocess module detected"
+      },
       { pattern: /exec\s*\(/i, message: "exec() function detected" },
       { pattern: /eval\s*\(/i, message: "eval() function detected" },
       { pattern: /__import__/i, message: "__import__ detected" },
-      { pattern: /open\s*\([^)]*['"]\//i, message: "Absolute path file access detected" },
-      { pattern: /require\s*\([^)]*child_process/i, message: "child_process module detected" },
+      {
+        pattern: /open\s*\([^)]*['"]\//i,
+        message: "Absolute path file access detected"
+      },
+      {
+        pattern: /require\s*\([^)]*child_process/i,
+        message: "child_process module detected"
+      },
       { pattern: /require\s*\([^)]*fs/i, message: "fs module access detected" }
     ];
     for (const { pattern, message } of dangerousPatterns) {

package/dist/src/integrations/mcp/handlers/cord-handlers.js

@@ -0,0 +1,397 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { randomUUID } from "crypto";
+import { logger } from "../../../core/monitoring/logger.js";
+class CordHandlers {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  MAX_DEPTH = 10;
+  MAX_TASKS = 50;
+  /**
+   * cord_spawn — create a child task with clean context (only blocker results visible)
+   */
+  async handleCordSpawn(args) {
+    return this.createTask(args, "spawn");
+  }
+  /**
+   * cord_fork — create a child task with full sibling context
+   */
+  async handleCordFork(args) {
+    return this.createTask(args, "fork");
+  }
+  /**
+   * cord_complete — mark a task as completed and unblock dependents
+   */
+  async handleCordComplete(args) {
+    try {
+      const { task_id, result } = args;
+      if (!task_id) throw new Error("task_id is required");
+      if (result === void 0 || result === null) {
+        throw new Error("result is required");
+      }
+      const db = this.deps.dbAdapter.getRawDatabase();
+      if (!db) throw new Error("Database not available");
+      const task = db.prepare("SELECT * FROM cord_tasks WHERE task_id = ?").get(task_id);
+      if (!task) throw new Error(`Task not found: ${task_id}`);
+      if (task.status === "completed") {
+        throw new Error(`Task already completed: ${task_id}`);
+      }
+      const now = Math.floor(Date.now() / 1e3);
+      db.prepare(
+        "UPDATE cord_tasks SET status = ?, result = ?, completed_at = ? WHERE task_id = ?"
+      ).run("completed", String(result), now, task_id);
+      const unblocked = this.checkAndUnblockDependents(db, task_id);
+      logger.info("Cord task completed", { task_id, unblocked });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Task ${task_id} completed.${unblocked.length > 0 ? ` Unblocked: ${unblocked.join(", ")}` : ""}`
+          }
+        ],
+        metadata: { task_id, status: "completed", unblocked }
+      };
+    } catch (error) {
+      logger.error(
+        "Error completing cord task",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+  /**
+   * cord_ask — create an "ask" task (question with optional options)
+   */
+  async handleCordAsk(args) {
+    try {
+      const { question, options, parent_id } = args;
+      if (!question) throw new Error("question is required");
+      const db = this.deps.dbAdapter.getRawDatabase();
+      if (!db) throw new Error("Database not available");
+      const projectId = this.getProjectId();
+      const runId = this.getRunId();
+      const taskId = randomUUID();
+      this.checkTaskLimit(db, projectId);
+      let depth = 0;
+      if (parent_id) {
+        depth = this.computeDepth(db, parent_id);
+      }
+      const prompt = options ? JSON.stringify({ question, options }) : JSON.stringify({ question });
+      db.prepare(
+        `INSERT INTO cord_tasks (task_id, parent_id, project_id, run_id, goal, prompt, status, context_mode, depth)
+         VALUES (?, ?, ?, ?, ?, ?, 'asked', 'ask', ?)`
+      ).run(
+        taskId,
+        parent_id || null,
+        projectId,
+        runId,
+        question,
+        prompt,
+        depth
+      );
+      logger.info("Cord ask created", { task_id: taskId });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Ask created: ${taskId} \u2014 "${question}"`
+          }
+        ],
+        metadata: {
+          task_id: taskId,
+          status: "asked",
+          context_mode: "ask",
+          question,
+          options: options || null
+        }
+      };
+    } catch (error) {
+      logger.error(
+        "Error creating cord ask",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+  /**
+   * cord_tree — view the task tree with context scoping
+   */
+  async handleCordTree(args) {
+    try {
+      const { task_id, include_results = false } = args;
+      const db = this.deps.dbAdapter.getRawDatabase();
+      if (!db) throw new Error("Database not available");
+      const projectId = this.getProjectId();
+      let tasks;
+      if (task_id) {
+        tasks = this.getSubtree(db, task_id);
+      } else {
+        tasks = db.prepare(
+          "SELECT * FROM cord_tasks WHERE project_id = ? ORDER BY depth ASC, created_at ASC"
+        ).all(projectId);
+      }
+      if (tasks.length === 0) {
+        return {
+          content: [{ type: "text", text: "No cord tasks found." }],
+          metadata: { tasks: [] }
+        };
+      }
+      const taskMap = /* @__PURE__ */ new Map();
+      for (const t of tasks) taskMap.set(t.task_id, t);
+      const allTasks = db.prepare(
+        "SELECT * FROM cord_tasks WHERE project_id = ? ORDER BY depth ASC, created_at ASC"
+      ).all(projectId);
+      const allTaskMap = /* @__PURE__ */ new Map();
+      for (const t of allTasks) allTaskMap.set(t.task_id, t);
+      const treeNodes = tasks.map((t) => {
+        const blockedBy = JSON.parse(t.blocked_by);
+        const node = {
+          task_id: t.task_id,
+          goal: t.goal,
+          status: t.status,
+          context_mode: t.context_mode,
+          depth: t.depth,
+          blocked_by: blockedBy,
+          parent_id: t.parent_id
+        };
+        if (include_results && t.result !== null) {
+          node.result = t.result;
+        }
+        node.visible_context = this.computeVisibleContext(
+          t,
+          allTaskMap,
+          include_results
+        );
+        return node;
+      });
+      const summary = tasks.map(
+        (t) => `${"  ".repeat(t.depth)}[${t.status}] ${t.goal}${t.context_mode === "ask" ? " (ask)" : ""}`
+      ).join("\n");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Cord Tree (${tasks.length} tasks):
+${summary}`
+          }
+        ],
+        metadata: { tasks: treeNodes }
+      };
+    } catch (error) {
+      logger.error(
+        "Error getting cord tree",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+  // --- Private helpers ---
+  async createTask(args, contextMode) {
+    try {
+      const { goal, prompt = "", blocked_by = [], parent_id } = args;
+      if (!goal) throw new Error("goal is required");
+      const db = this.deps.dbAdapter.getRawDatabase();
+      if (!db) throw new Error("Database not available");
+      const projectId = this.getProjectId();
+      const runId = this.getRunId();
+      const taskId = randomUUID();
+      this.checkTaskLimit(db, projectId);
+      let depth = 0;
+      if (parent_id) {
+        depth = this.computeDepth(db, parent_id);
+      }
+      const blockerIds = Array.isArray(blocked_by) ? blocked_by : [];
+      if (blockerIds.length > 0) {
+        this.validateBlockers(db, blockerIds);
+        this.detectCircularDeps(db, taskId, blockerIds);
+      }
+      const status = this.initialStatus(db, blockerIds);
+      db.prepare(
+        `INSERT INTO cord_tasks (task_id, parent_id, project_id, run_id, goal, prompt, status, context_mode, blocked_by, depth)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        taskId,
+        parent_id || null,
+        projectId,
+        runId,
+        goal,
+        prompt,
+        status,
+        contextMode,
+        JSON.stringify(blockerIds),
+        depth
+      );
+      logger.info("Cord task created", {
+        task_id: taskId,
+        context_mode: contextMode,
+        status
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Task ${taskId} created (${contextMode}, ${status}): ${goal}`
+          }
+        ],
+        metadata: {
+          task_id: taskId,
+          status,
+          context_mode: contextMode,
+          depth,
+          blocked_by: blockerIds
+        }
+      };
+    } catch (error) {
+      logger.error(
+        "Error creating cord task",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+  checkTaskLimit(db, projectId) {
+    const row = db.prepare("SELECT COUNT(*) as count FROM cord_tasks WHERE project_id = ?").get(projectId);
+    if (row.count >= this.MAX_TASKS) {
+      throw new Error(
+        `Task limit reached: ${this.MAX_TASKS} tasks per project`
+      );
+    }
+  }
+  computeDepth(db, parentId) {
+    const parent = db.prepare("SELECT depth FROM cord_tasks WHERE task_id = ?").get(parentId);
+    if (!parent) throw new Error(`Parent task not found: ${parentId}`);
+    const depth = parent.depth + 1;
+    if (depth >= this.MAX_DEPTH) {
+      throw new Error(`Max depth exceeded: ${this.MAX_DEPTH}`);
+    }
+    return depth;
+  }
+  validateBlockers(db, blockerIds) {
+    for (const id of blockerIds) {
+      const exists = db.prepare("SELECT 1 FROM cord_tasks WHERE task_id = ?").get(id);
+      if (!exists) throw new Error(`Blocker task not found: ${id}`);
+    }
+  }
+  detectCircularDeps(db, newTaskId, blockerIds) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [...blockerIds];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (current === newTaskId) {
+        throw new Error("Circular dependency detected");
+      }
+      if (visited.has(current)) continue;
+      visited.add(current);
+      const task = db.prepare("SELECT blocked_by FROM cord_tasks WHERE task_id = ?").get(current);
+      if (task) {
+        const deps = JSON.parse(task.blocked_by);
+        for (const dep of deps) {
+          if (!visited.has(dep)) queue.push(dep);
+        }
+      }
+    }
+  }
+  initialStatus(db, blockerIds) {
+    if (blockerIds.length === 0) return "active";
+    for (const id of blockerIds) {
+      const task = db.prepare("SELECT status FROM cord_tasks WHERE task_id = ?").get(id);
+      if (!task || task.status !== "completed") return "blocked";
+    }
+    return "active";
+  }
+  checkAndUnblockDependents(db, completedTaskId) {
+    const allBlocked = db.prepare("SELECT * FROM cord_tasks WHERE status = 'blocked'").all();
+    const unblocked = [];
+    for (const task of allBlocked) {
+      const blockers = JSON.parse(task.blocked_by);
+      if (!blockers.includes(completedTaskId)) continue;
+      const allDone = blockers.every((bid) => {
+        if (bid === completedTaskId) return true;
+        const blocker = db.prepare("SELECT status FROM cord_tasks WHERE task_id = ?").get(bid);
+        return blocker?.status === "completed";
+      });
+      if (allDone) {
+        db.prepare(
+          "UPDATE cord_tasks SET status = 'active' WHERE task_id = ?"
+        ).run(task.task_id);
+        unblocked.push(task.task_id);
+      }
+    }
+    return unblocked;
+  }
+  getSubtree(db, rootId) {
+    const result = [];
+    const queue = [rootId];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      const task = db.prepare("SELECT * FROM cord_tasks WHERE task_id = ?").get(current);
+      if (task) {
+        result.push(task);
+        const children = db.prepare(
+          "SELECT task_id FROM cord_tasks WHERE parent_id = ? ORDER BY created_at ASC"
+        ).all(current);
+        for (const c of children) queue.push(c.task_id);
+      }
+    }
+    return result;
+  }
+  computeVisibleContext(task, allTaskMap, includeResults) {
+    const ctx = { prompt: task.prompt };
+    if (task.context_mode === "ask") {
+      try {
+        const parsed = JSON.parse(task.prompt);
+        ctx.question = parsed.question;
+        ctx.options = parsed.options || null;
+      } catch {
+        ctx.question = task.goal;
+      }
+      if (task.status === "completed" && task.result !== null) {
+        ctx.answer = task.result;
+      }
+      return ctx;
+    }
+    const blockerIds = JSON.parse(task.blocked_by);
+    const blockerResults = [];
+    for (const bid of blockerIds) {
+      const blocker = allTaskMap.get(bid);
+      if (blocker?.status === "completed" && blocker.result !== null) {
+        blockerResults.push({
+          task_id: bid,
+          goal: blocker.goal,
+          result: includeResults ? blocker.result : "[completed]"
+        });
+      }
+    }
+    if (blockerResults.length > 0) {
+      ctx.blocker_results = blockerResults;
+    }
+    if (task.context_mode === "fork" && task.parent_id) {
+      const siblingResults = [];
+      for (const [, t] of allTaskMap) {
+        if (t.parent_id === task.parent_id && t.task_id !== task.task_id && t.status === "completed" && t.result !== null) {
+          siblingResults.push({
+            task_id: t.task_id,
+            goal: t.goal,
+            result: includeResults ? t.result : "[completed]"
+          });
+        }
+      }
+      if (siblingResults.length > 0) {
+        ctx.sibling_results = siblingResults;
+      }
+    }
+    return ctx;
+  }
+  getProjectId() {
+    return this.deps.dbAdapter.projectId;
+  }
+  getRunId() {
+    return this.deps.frameManager.currentRunId;
+  }
+}
+export {
+  CordHandlers
+};

package/dist/src/integrations/mcp/handlers/index.js

@@ -18,6 +18,8 @@ import {
 import {
   ProviderHandlers
 } from "./provider-handlers.js";
+import { TeamHandlers } from "./team-handlers.js";
+import { CordHandlers } from "./cord-handlers.js";
 import {
   ContextHandlers as ContextHandlers2
 } from "./context-handlers.js";
@@ -27,12 +29,16 @@ import {
 } from "./linear-handlers.js";
 import { TraceHandlers as TraceHandlers2 } from "./trace-handlers.js";
 import { ProviderHandlers as ProviderHandlers2 } from "./provider-handlers.js";
+import { TeamHandlers as TeamHandlers2 } from "./team-handlers.js";
+import { CordHandlers as CordHandlers2 } from "./cord-handlers.js";
 class MCPHandlerFactory {
   contextHandlers;
   taskHandlers;
   linearHandlers;
   traceHandlers;
   providerHandlers;
+  teamHandlers;
+  cordHandlers;
   constructor(deps) {
     this.contextHandlers = new ContextHandlers2({
       frameManager: deps.frameManager
@@ -51,6 +57,16 @@ class MCPHandlerFactory {
       browserMCP: deps.browserMCP
     });
     this.providerHandlers = new ProviderHandlers2();
+    if (deps.dbAdapter) {
+      this.teamHandlers = new TeamHandlers2({
+        frameManager: deps.frameManager,
+        dbAdapter: deps.dbAdapter
+      });
+      this.cordHandlers = new CordHandlers2({
+        frameManager: deps.frameManager,
+        dbAdapter: deps.dbAdapter
+      });
+    }
   }
   /**
    * Get handler for a specific tool
@@ -83,10 +99,6 @@ class MCPHandlerFactory {
         return this.taskHandlers.handleGetActiveTasks.bind(this.taskHandlers);
       case "get_task_metrics":
         return this.taskHandlers.handleGetTaskMetrics.bind(this.taskHandlers);
-      case "add_task_dependency":
-        return this.taskHandlers.handleAddTaskDependency.bind(
-          this.taskHandlers
-        );
       // Linear handlers
       case "linear_sync":
         return this.linearHandlers.handleLinearSync.bind(this.linearHandlers);
@@ -103,8 +115,6 @@ class MCPHandlerFactory {
       // Trace handlers
       case "get_traces":
         return this.traceHandlers.handleGetTraces.bind(this.traceHandlers);
-      case "analyze_traces":
-        return this.traceHandlers.handleAnalyzeTraces.bind(this.traceHandlers);
       case "start_browser_debug":
         return this.traceHandlers.handleStartBrowserDebug.bind(
           this.traceHandlers
@@ -130,6 +140,32 @@ class MCPHandlerFactory {
         return this.providerHandlers.handleBatchCheck.bind(
           this.providerHandlers
         );
+      // Team handlers
+      case "team_context_get":
+        if (!this.teamHandlers) throw new Error("Team tools require dbAdapter");
+        return this.teamHandlers.handleTeamContextGet.bind(this.teamHandlers);
+      case "team_context_share":
+        if (!this.teamHandlers) throw new Error("Team tools require dbAdapter");
+        return this.teamHandlers.handleTeamContextShare.bind(this.teamHandlers);
+      case "team_search":
+        if (!this.teamHandlers) throw new Error("Team tools require dbAdapter");
+        return this.teamHandlers.handleTeamSearch.bind(this.teamHandlers);
+      // Cord orchestration handlers
+      case "cord_spawn":
+        if (!this.cordHandlers) throw new Error("Cord tools require dbAdapter");
+        return this.cordHandlers.handleCordSpawn.bind(this.cordHandlers);
+      case "cord_fork":
+        if (!this.cordHandlers) throw new Error("Cord tools require dbAdapter");
+        return this.cordHandlers.handleCordFork.bind(this.cordHandlers);
+      case "cord_complete":
+        if (!this.cordHandlers) throw new Error("Cord tools require dbAdapter");
+        return this.cordHandlers.handleCordComplete.bind(this.cordHandlers);
+      case "cord_ask":
+        if (!this.cordHandlers) throw new Error("Cord tools require dbAdapter");
+        return this.cordHandlers.handleCordAsk.bind(this.cordHandlers);
+      case "cord_tree":
+        if (!this.cordHandlers) throw new Error("Cord tools require dbAdapter");
+        return this.cordHandlers.handleCordTree.bind(this.cordHandlers);
       default:
         throw new Error(`Unknown tool: ${toolName}`);
     }
@@ -151,7 +187,6 @@ class MCPHandlerFactory {
       "update_task_status",
       "get_active_tasks",
       "get_task_metrics",
-      "add_task_dependency",
       // Linear tools
       "linear_sync",
       "linear_update_task",
@@ -159,7 +194,6 @@ class MCPHandlerFactory {
       "linear_status",
       // Trace tools
       "get_traces",
-      "analyze_traces",
       "start_browser_debug",
       "take_screenshot",
       "execute_script",
@@ -167,7 +201,17 @@ class MCPHandlerFactory {
       // Provider tools (conditionally active)
       "delegate_to_model",
       "batch_submit",
-      "batch_check"
+      "batch_check",
+      // Team tools
+      "team_context_get",
+      "team_context_share",
+      "team_search",
+      // Cord orchestration tools
+      "cord_spawn",
+      "cord_fork",
+      "cord_complete",
+      "cord_ask",
+      "cord_tree"
     ];
   }
   /**
@@ -179,10 +223,12 @@ class MCPHandlerFactory {
 }
 export {
   ContextHandlers,
+  CordHandlers,
   DiscoveryHandlers,
   LinearHandlers,
   MCPHandlerFactory,
   ProviderHandlers,
   TaskHandlers,
+  TeamHandlers,
   TraceHandlers
 };