@axiom-lattice/core 2.1.23 → 2.1.24

package/dist/index.mjs

@@ -508,11 +508,11 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
    * @param key Lattice键名
    * @param tool 已有的StructuredTool实例
    */
-  registerExistingTool(key, tool36) {
+  registerExistingTool(key, tool38) {
     const config = {
-      name: tool36.name,
-      description: tool36.description,
-      schema: tool36.schema,
+      name: tool38.name,
+      description: tool38.description,
+      schema: tool38.schema,
       // StructuredTool的schema已经是Zod兼容的
       needUserApprove: false
       // MCP工具默认不需要用户批准
@@ -520,7 +520,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
     const toolLattice = {
       key,
       config,
-      client: tool36
+      client: tool38
     };
     this.register(key, toolLattice);
   }
@@ -546,7 +546,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
 };
 var toolLatticeManager = ToolLatticeManager.getInstance();
 var registerToolLattice = (key, config, executor) => toolLatticeManager.registerLattice(key, config, executor);
-var registerExistingTool = (key, tool36) => toolLatticeManager.registerExistingTool(key, tool36);
+var registerExistingTool = (key, tool38) => toolLatticeManager.registerExistingTool(key, tool38);
 var getToolLattice = (key) => toolLatticeManager.getToolLattice(key);
 var getToolDefinition = (key) => toolLatticeManager.getToolDefinition(key);
 var getToolClient = (key) => toolLatticeManager.getToolClient(key);
@@ -618,7 +618,7 @@ var PostgresDatabase = class {
     this.config = config;
   }
   async connect() {
-    if (this.connected) return;
+    if (this.connected && this.pool) return;
     try {
       const { Pool } = await import("pg");
       const poolConfig = this.config.connectionString ? { connectionString: this.config.connectionString } : {
@@ -631,16 +631,27 @@ var PostgresDatabase = class {
       };
       this.pool = new Pool(poolConfig);
       const client = await this.pool.connect();
-      client.release();
+      try {
+        await client.query("SELECT 1");
+      } finally {
+        client.release();
+      }
       this.connected = true;
     } catch (error) {
+      this.connected = false;
       throw new Error(`Failed to connect to PostgreSQL: ${error}`);
     }
   }
   async disconnect() {
     if (this.pool) {
-      await this.pool.end();
-      this.connected = false;
+      try {
+        await this.pool.end();
+      } catch (error) {
+        console.warn("Warning: Error closing PostgreSQL pool:", error);
+      } finally {
+        this.pool = null;
+        this.connected = false;
+      }
     }
   }
   async listTables() {
@@ -836,45 +847,55 @@ var SqlDatabaseManager = class _SqlDatabaseManager {
       await database.disconnect();
     }
   }
-};
-function parseConnectionString(connectionString) {
-  const url = new URL(connectionString);
-  const protocol = url.protocol.replace(":", "");
-  if (protocol !== "postgres" && protocol !== "postgresql") {
-    throw new Error(`Unsupported protocol: ${protocol}. Only postgresql:// is supported.`);
+  /**
+   * Load database configurations from a DatabaseConfigStore
+   * and register them with this manager
+   * 
+   * @param store - The database configuration store
+   * @param tenantId - Tenant identifier
+   */
+  async loadConfigsFromStore(store, tenantId) {
+    const configs = await store.getAllConfigs(tenantId);
+    for (const entry of configs) {
+      this.registerDatabase(entry.key, entry.config);
+    }
   }
-  return {
-    host: url.hostname || "localhost",
-    port: parseInt(url.port || "5432"),
-    database: url.pathname.slice(1) || url.pathname,
-    user: url.username,
-    password: url.password,
-    ssl: url.searchParams.get("sslmode") === "require"
-  };
-}
+  /**
+   * Load all database configurations from a DatabaseConfigStore
+   * across all tenants and register them with this manager
+   * 
+   * @param store - The database configuration store
+   */
+  async loadAllConfigsFromStore(store) {
+    const configs = await store.getAllConfigsWithoutTenant();
+    for (const entry of configs) {
+      this.registerDatabase(entry.key, entry.config);
+    }
+  }
+};
 var sqlDatabaseManager = SqlDatabaseManager.getInstance();
 
 // src/tool_lattice/sql/list_tables_sql.ts
 import z3 from "zod";
 import { tool as tool2 } from "langchain";
 var LIST_TABLES_SQL_DESCRIPTION = `List all tables in the connected SQL database. Returns a comma-separated list of table names. Use this tool first to understand what tables are available before querying the database.`;
-var createListTablesSqlTool = ({ databaseKey, connectionString }) => {
+var createListTablesSqlTool = ({ databaseKeys, databaseDescriptions }) => {
+  const availableDbsText = databaseKeys.length > 0 ? `
+
+Available databases:
+${databaseKeys.map(
+    (key) => `- ${key}${databaseDescriptions?.[key] ? `: ${databaseDescriptions[key]}` : ""}`
+  ).join("\n")}` : "";
   return tool2(
-    async (_input, exe_config) => {
+    async ({ databaseKey }, exe_config) => {
       try {
-        let dbKey;
-        if (databaseKey) {
-          dbKey = databaseKey;
-        } else if (connectionString) {
-          dbKey = connectionString;
-          if (!sqlDatabaseManager.hasDatabase(dbKey)) {
-            const config = parseConnectionString(connectionString);
-            sqlDatabaseManager.registerDatabase(dbKey, { ...config, type: "postgres" });
-          }
-        } else {
-          return "Error: Must provide databaseKey or connectionString";
+        if (!databaseKey) {
+          return "Error: databaseKey parameter is required. Available databases: " + databaseKeys.join(", ");
         }
-        const database = sqlDatabaseManager.getDatabase(dbKey);
+        if (!databaseKeys.includes(databaseKey)) {
+          return `Error: databaseKey "${databaseKey}" is not in the allowed list: [${databaseKeys.join(", ")}]`;
+        }
+        const database = sqlDatabaseManager.getDatabase(databaseKey);
         const tables = await database.listTables();
         if (tables.length === 0) {
           return "No tables found in the database.";
@@ -889,8 +910,10 @@ var createListTablesSqlTool = ({ databaseKey, connectionString }) => {
     },
     {
       name: "list_tables_sql",
-      description: LIST_TABLES_SQL_DESCRIPTION,
-      schema: z3.object({})
+      description: `${LIST_TABLES_SQL_DESCRIPTION}${availableDbsText}`,
+      schema: z3.object({
+        databaseKey: z3.string().describe(`Target database to list tables. Choose from: ${databaseKeys.join(", ")}`)
+      })
     }
   );
 };
@@ -899,49 +922,26 @@ var createListTablesSqlTool = ({ databaseKey, connectionString }) => {
 import z4 from "zod";
 import { tool as tool3 } from "langchain";
 var INFO_SQL_DESCRIPTION = `Get detailed schema information for specified tables, including column names, types, constraints (primary keys, foreign keys), and sample rows. Input should be a comma-separated list of table names.`;
-function formatTableSchema(schema) {
-  const lines = [];
-  lines.push(`
-Table: ${schema.tableName}`);
-  lines.push("-".repeat(40));
-  lines.push("Columns:");
-  for (const col of schema.columns) {
-    const constraints = [];
-    if (col.isPrimaryKey) constraints.push("PRIMARY KEY");
-    if (col.isForeignKey && col.foreignKeyRef)
-      constraints.push(`FK -> ${col.foreignKeyRef}`);
-    if (!col.nullable) constraints.push("NOT NULL");
-    const constraintStr = constraints.length > 0 ? ` [${constraints.join(", ")}]` : "";
-    lines.push(`  - ${col.name}: ${col.type}${constraintStr}`);
-  }
-  if (schema.sampleRows && schema.sampleRows.length > 0) {
-    lines.push("\nSample Rows (up to 3):");
-    for (const row of schema.sampleRows) {
-      const rowStr = Object.entries(row).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ");
-      lines.push(`  ${rowStr}`);
-    }
-  }
-  return lines.join("\n");
-}
-var createInfoSqlTool = ({ databaseKey, connectionString }) => {
+var createInfoSqlTool = ({ databaseKeys, databaseDescriptions }) => {
+  const availableDbsText = databaseKeys.length > 0 ? `
+
+Available databases:
+${databaseKeys.map(
+    (key) => `- ${key}${databaseDescriptions?.[key] ? `: ${databaseDescriptions[key]}` : ""}`
+  ).join("\n")}` : "";
   return tool3(
     async ({
-      tables
+      tables,
+      databaseKey
     }, exe_config) => {
       try {
-        let dbKey;
-        if (databaseKey) {
-          dbKey = databaseKey;
-        } else if (connectionString) {
-          dbKey = connectionString;
-          if (!sqlDatabaseManager.hasDatabase(dbKey)) {
-            const config = parseConnectionString(connectionString);
-            sqlDatabaseManager.registerDatabase(dbKey, { ...config, type: "postgres" });
-          }
-        } else {
-          return "Error: Must provide databaseKey or connectionString";
+        if (!databaseKey) {
+          return "Error: databaseKey parameter is required. Available databases: " + databaseKeys.join(", ");
+        }
+        if (!databaseKeys.includes(databaseKey)) {
+          return `Error: databaseKey "${databaseKey}" is not in the allowed list: [${databaseKeys.join(", ")}]`;
         }
-        const database = sqlDatabaseManager.getDatabase(dbKey);
+        const database = sqlDatabaseManager.getDatabase(databaseKey);
         const tableNames = tables.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
         if (tableNames.length === 0) {
           return "Error: No table names provided. Please provide a comma-separated list of table names.";
@@ -958,15 +958,40 @@ var createInfoSqlTool = ({ databaseKey, connectionString }) => {
     },
     {
       name: "info_sql",
-      description: INFO_SQL_DESCRIPTION,
+      description: `${INFO_SQL_DESCRIPTION}${availableDbsText}`,
       schema: z4.object({
         tables: z4.string().describe(
           "Comma-separated list of table names to get information for. Example: 'users, orders, products'"
-        )
+        ),
+        databaseKey: z4.string().describe(`Target database to get table info. Choose from: ${databaseKeys.join(", ")}`)
       })
     }
   );
 };
+function formatTableSchema(schema) {
+  const lines = [];
+  lines.push(`
+Table: ${schema.tableName}`);
+  lines.push("-".repeat(40));
+  lines.push("Columns:");
+  for (const col of schema.columns) {
+    const constraints = [];
+    if (col.isPrimaryKey) constraints.push("PRIMARY KEY");
+    if (col.isForeignKey && col.foreignKeyRef)
+      constraints.push(`FK -> ${col.foreignKeyRef}`);
+    if (!col.nullable) constraints.push("NOT NULL");
+    const constraintStr = constraints.length > 0 ? ` [${constraints.join(", ")}]` : "";
+    lines.push(`  - ${col.name}: ${col.type}${constraintStr}`);
+  }
+  if (schema.sampleRows && schema.sampleRows.length > 0) {
+    lines.push("\nSample Rows (up to 3):");
+    for (const row of schema.sampleRows) {
+      const rowStr = Object.entries(row).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ");
+      lines.push(`  ${rowStr}`);
+    }
+  }
+  return lines.join("\n");
+}
 
 // src/tool_lattice/sql/query_checker_sql.ts
 import z5 from "zod";
@@ -1028,10 +1053,17 @@ function checkDangerousOperations(query) {
   }
   return warnings;
 }
-var createQueryCheckerSqlTool = ({ databaseKey, connectionString }) => {
+var createQueryCheckerSqlTool = ({ databaseKeys, databaseDescriptions }) => {
+  const availableDbsText = databaseKeys.length > 0 ? `
+
+Available databases:
+${databaseKeys.map(
+    (key) => `- ${key}${databaseDescriptions?.[key] ? `: ${databaseDescriptions[key]}` : ""}`
+  ).join("\n")}` : "";
   return tool4(
     async ({
-      query
+      query,
+      databaseKey
     }, exe_config) => {
       try {
         const trimmedQuery = query.trim();
@@ -1063,19 +1095,9 @@ ${trimmedQuery}
         } else {
           results.push("Safety: No dangerous operations detected");
         }
-        try {
-          let dbKey;
-          if (databaseKey) {
-            dbKey = databaseKey;
-          } else if (connectionString) {
-            dbKey = connectionString;
-            if (!sqlDatabaseManager.hasDatabase(dbKey)) {
-              const config = parseConnectionString(connectionString);
-              sqlDatabaseManager.registerDatabase(dbKey, { ...config, type: "postgres" });
-            }
-          }
-          if (dbKey) {
-            const database = sqlDatabaseManager.getDatabase(dbKey);
+        if (databaseKey && databaseKeys.includes(databaseKey)) {
+          try {
+            const database = sqlDatabaseManager.getDatabase(databaseKey);
             const dbType = database.getDatabaseType();
             if (dbType === "postgres") {
               try {
@@ -1087,10 +1109,14 @@ ${trimmedQuery}
                 );
               }
             }
+          } catch {
+            results.push(
+              "Database Validation: Skipped (database connection unavailable)"
+            );
           }
-        } catch {
+        } else {
           results.push(
-            "Database Validation: Skipped (no database connection available)"
+            "Database Validation: Skipped (no valid databaseKey provided)"
           );
         }
         const hasErrors = syntaxIssues.some((i) => !i.startsWith("Warning:")) || dangerWarnings.length > 0;
@@ -1109,9 +1135,10 @@ ${trimmedQuery}
     },
     {
       name: "query_checker_sql",
-      description: "Check a SQL query for common issues before execution. This tool validates syntax, checks for dangerous operations, and provides suggestions for improvement. Use this before executing queries to ensure they are safe and correct.",
+      description: `Check a SQL query for common issues before execution. This tool validates syntax, checks for dangerous operations, and provides suggestions for improvement. Use this before executing queries to ensure they are safe and correct.${availableDbsText}`,
       schema: z5.object({
-        query: z5.string().describe("The SQL query to check and validate.")
+        query: z5.string().describe("The SQL query to check and validate."),
+        databaseKey: z5.string().describe(`Target database to validate query against. Choose from: ${databaseKeys.join(", ")}`)
       })
     }
   );
@@ -1120,7 +1147,6 @@ ${trimmedQuery}
 // src/tool_lattice/sql/query_sql.ts
 import z6 from "zod";
 import { tool as tool5 } from "langchain";
-var QUERY_SQL_DESCRIPTION = `Execute a SQL query against the database and return the results. Input should be a valid SQL query. Use this tool to retrieve data from the database. For complex queries, first use list_tables_sql and info_sql to understand the database schema.`;
 function formatQueryResult(rows, fields) {
   if (rows.length === 0) {
     return "Query executed successfully. No rows returned.";
@@ -1148,29 +1174,30 @@ function formatQueryResult(rows, fields) {
 Total rows: ${rows.length}`);
   return lines.join("\n");
 }
-var createQuerySqlTool = ({ databaseKey, connectionString }) => {
+var createQuerySqlTool = ({ databaseKeys, databaseDescriptions }) => {
+  const availableDbsText = databaseKeys.length > 0 ? `
+
+Available databases:
+${databaseKeys.map(
+    (key) => `- ${key}${databaseDescriptions?.[key] ? `: ${databaseDescriptions[key]}` : ""}`
+  ).join("\n")}` : "";
   return tool5(
     async ({
-      query
+      query,
+      databaseKey
     }, exe_config) => {
       try {
-        let dbKey;
-        if (databaseKey) {
-          dbKey = databaseKey;
-        } else if (connectionString) {
-          dbKey = connectionString;
-          if (!sqlDatabaseManager.hasDatabase(dbKey)) {
-            const config = parseConnectionString(connectionString);
-            sqlDatabaseManager.registerDatabase(dbKey, { ...config, type: "postgres" });
-          }
-        } else {
-          return "Error: Must provide databaseKey or connectionString";
+        if (!databaseKey) {
+          return "Error: databaseKey parameter is required. Available databases: " + databaseKeys.join(", ");
+        }
+        if (!databaseKeys.includes(databaseKey)) {
+          return `Error: databaseKey "${databaseKey}" is not in the allowed list: [${databaseKeys.join(", ")}]`;
         }
         const trimmedQuery = query.trim();
         if (!trimmedQuery) {
           return "Error: Empty query provided. Please provide a valid SQL query.";
         }
-        const database = sqlDatabaseManager.getDatabase(dbKey);
+        const database = sqlDatabaseManager.getDatabase(databaseKey);
         const result = await database.executeQuery(trimmedQuery);
         return formatQueryResult(result.rows, result.fields);
       } catch (error) {
@@ -1179,11 +1206,12 @@ var createQuerySqlTool = ({ databaseKey, connectionString }) => {
     },
     {
       name: "query_sql",
-      description: QUERY_SQL_DESCRIPTION,
+      description: `Execute a SQL query against the database and return the results.${availableDbsText}`,
       schema: z6.object({
         query: z6.string().describe(
           "The SQL query to execute. Should be a valid SELECT, INSERT, UPDATE, or DELETE statement."
-        )
+        ),
+        databaseKey: z6.string().describe(`Target database to execute the query. Choose from: ${databaseKeys.join(", ")}`)
       })
     }
   );
@@ -2471,10 +2499,13 @@ import {
   AgentConfig,
   ReactAgentConfig,
   DeepAgentConfig,
+  TeamAgentConfig,
+  TeamTeammateConfig,
   AgentConfigWithTools,
   GraphBuildOptions,
   hasTools,
   isDeepAgentConfig,
+  isTeamAgentConfig,
   getToolsFromConfig,
   getSubAgentsFromConfig
 } from "@axiom-lattice/protocols";
@@ -2610,8 +2641,8 @@ var SandboxFilesystem = class {
    */
   toVirtualPath(realPath) {
     const rootPath = path2.join(this.homeDir, this.workingDirectory);
-    const relative2 = path2.relative(rootPath, realPath);
-    const normalized = relative2.split(path2.sep).join("/");
+    const relative3 = path2.relative(rootPath, realPath);
+    const normalized = relative3.split(path2.sep).join("/");
     return "/" + normalized;
   }
   /**
@@ -2893,17 +2924,17 @@ function createBrowserMiddleware(params = { isolatedLevel: "global" }) {
 // src/middlewares/sqlMiddleware.ts
 import { createMiddleware as createMiddleware3 } from "langchain";
 function createSqlMiddleware(params) {
-  const { connectionMode, databaseKey, connectionString } = params;
-  const toolParams = {};
-  if (connectionMode === "databaseKey" && databaseKey) {
-    toolParams.databaseKey = databaseKey;
-  } else if (connectionString) {
-    toolParams.connectionString = connectionString;
-  } else if (databaseKey) {
-    toolParams.databaseKey = databaseKey;
-  } else if (connectionString) {
-    toolParams.connectionString = connectionString;
+  const { databaseKeys, databaseDescriptions } = params;
+  if (!databaseKeys || databaseKeys.length === 0) {
+    return createMiddleware3({
+      name: "sqlMiddleware",
+      tools: []
+    });
   }
+  const toolParams = {
+    databaseKeys,
+    databaseDescriptions
+  };
   return createMiddleware3({
     name: "sqlMiddleware",
     tools: [
@@ -3568,6 +3599,258 @@ ${body}` : `${frontmatter}
   }
 };
 
+// src/store_lattice/InMemoryWorkspaceStore.ts
+var InMemoryWorkspaceStore = class {
+  constructor() {
+    this.workspaces = /* @__PURE__ */ new Map();
+    this.initDefaultData();
+  }
+  initDefaultData() {
+    const defaultTenantId = "default";
+    const now = /* @__PURE__ */ new Date();
+    const defaultWorkspace = {
+      id: "default-workspace",
+      tenantId: defaultTenantId,
+      name: "\u9ED8\u8BA4\u5DE5\u4F5C\u533A",
+      description: "\u7CFB\u7EDF\u9ED8\u8BA4\u5DE5\u4F5C\u533A",
+      storageType: "sandbox",
+      createdAt: now,
+      updatedAt: now
+    };
+    this.workspaces.set(`${defaultTenantId}:default-workspace`, defaultWorkspace);
+  }
+  getKey(tenantId, id) {
+    return `${tenantId}:${id}`;
+  }
+  async getAllWorkspaces(tenantId) {
+    return Array.from(this.workspaces.values()).filter(
+      (w) => w.tenantId === tenantId
+    );
+  }
+  async getWorkspaceById(tenantId, id) {
+    const key = this.getKey(tenantId, id);
+    return this.workspaces.get(key) || null;
+  }
+  async createWorkspace(tenantId, id, data) {
+    const now = /* @__PURE__ */ new Date();
+    const workspace = {
+      id,
+      tenantId,
+      name: data.name,
+      description: data.description,
+      storageType: data.storageType,
+      createdAt: now,
+      updatedAt: now
+    };
+    const key = this.getKey(tenantId, id);
+    this.workspaces.set(key, workspace);
+    return workspace;
+  }
+  async updateWorkspace(tenantId, id, updates) {
+    const key = this.getKey(tenantId, id);
+    const existing = this.workspaces.get(key);
+    if (!existing) {
+      return null;
+    }
+    const updated = {
+      ...existing,
+      ...updates,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.workspaces.set(key, updated);
+    return updated;
+  }
+  async deleteWorkspace(tenantId, id) {
+    const key = this.getKey(tenantId, id);
+    return this.workspaces.delete(key);
+  }
+  clear() {
+    this.workspaces.clear();
+  }
+};
+
+// src/store_lattice/InMemoryProjectStore.ts
+var InMemoryProjectStore = class {
+  constructor() {
+    this.projects = /* @__PURE__ */ new Map();
+    this.initDefaultData();
+  }
+  initDefaultData() {
+    const defaultTenantId = "default";
+    const defaultWorkspaceId = "default-workspace";
+    const now = /* @__PURE__ */ new Date();
+    const defaultProject = {
+      id: "default-project",
+      tenantId: defaultTenantId,
+      workspaceId: defaultWorkspaceId,
+      name: "\u9ED8\u8BA4\u9879\u76EE",
+      description: "\u7CFB\u7EDF\u9ED8\u8BA4\u9879\u76EE",
+      createdAt: now,
+      updatedAt: now
+    };
+    this.projects.set(`${defaultTenantId}:default-project`, defaultProject);
+  }
+  getKey(tenantId, id) {
+    return `${tenantId}:${id}`;
+  }
+  async getProjectsByWorkspace(tenantId, workspaceId) {
+    return Array.from(this.projects.values()).filter(
+      (p) => p.tenantId === tenantId && p.workspaceId === workspaceId
+    );
+  }
+  async getProjectById(tenantId, id) {
+    const key = this.getKey(tenantId, id);
+    return this.projects.get(key) || null;
+  }
+  async createProject(tenantId, workspaceId, id, data) {
+    const now = /* @__PURE__ */ new Date();
+    const project = {
+      id,
+      tenantId,
+      workspaceId,
+      name: data.name,
+      description: data.description,
+      createdAt: now,
+      updatedAt: now
+    };
+    const key = this.getKey(tenantId, id);
+    this.projects.set(key, project);
+    return project;
+  }
+  async updateProject(tenantId, id, updates) {
+    const key = this.getKey(tenantId, id);
+    const existing = this.projects.get(key);
+    if (!existing) {
+      return null;
+    }
+    const updated = {
+      ...existing,
+      ...updates,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.projects.set(key, updated);
+    return updated;
+  }
+  async deleteProject(tenantId, id) {
+    const key = this.getKey(tenantId, id);
+    return this.projects.delete(key);
+  }
+  clear() {
+    this.projects.clear();
+  }
+};
+
+// src/store_lattice/InMemoryDatabaseConfigStore.ts
+var InMemoryDatabaseConfigStore = class {
+  constructor() {
+    this.configs = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get composite key for storage
+   */
+  getKey(tenantId, id) {
+    return `${tenantId}:${id}`;
+  }
+  /**
+   * Get all database configurations for a tenant
+   */
+  async getAllConfigs(tenantId) {
+    return Array.from(this.configs.values()).filter(
+      (config) => config.tenantId === tenantId
+    );
+  }
+  /**
+   * Get all database configurations across all tenants
+   */
+  async getAllConfigsWithoutTenant() {
+    return Array.from(this.configs.values());
+  }
+  /**
+   * Get database configuration by ID
+   */
+  async getConfigById(tenantId, id) {
+    const key = this.getKey(tenantId, id);
+    return this.configs.get(key) || null;
+  }
+  /**
+   * Get database configuration by business key
+   */
+  async getConfigByKey(tenantId, key) {
+    const configs = await this.getAllConfigs(tenantId);
+    return configs.find((config) => config.key === key) || null;
+  }
+  /**
+   * Create a new database configuration
+   */
+  async createConfig(tenantId, id, data) {
+    const now = /* @__PURE__ */ new Date();
+    const entry = {
+      id,
+      tenantId,
+      key: data.key,
+      config: data.config,
+      name: data.name,
+      description: data.description,
+      createdAt: now,
+      updatedAt: now
+    };
+    const storageKey = this.getKey(tenantId, id);
+    this.configs.set(storageKey, entry);
+    return entry;
+  }
+  /**
+   * Update an existing database configuration
+   */
+  async updateConfig(tenantId, id, updates) {
+    const key = this.getKey(tenantId, id);
+    const existing = this.configs.get(key);
+    if (!existing) {
+      return null;
+    }
+    const updated = {
+      ...existing,
+      ...updates,
+      config: updates.config ? { ...existing.config, ...updates.config } : existing.config,
+      key: updates.key || existing.key,
+      name: updates.name !== void 0 ? updates.name : existing.name,
+      description: updates.description !== void 0 ? updates.description : existing.description,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.configs.set(key, updated);
+    return updated;
+  }
+  /**
+   * Delete a database configuration by ID
+   */
+  async deleteConfig(tenantId, id) {
+    const key = this.getKey(tenantId, id);
+    return this.configs.delete(key);
+  }
+  /**
+   * Check if configuration exists
+   */
+  async hasConfig(tenantId, id) {
+    const key = this.getKey(tenantId, id);
+    return this.configs.has(key);
+  }
+  /**
+   * Clear all configurations (useful for testing)
+   */
+  clear() {
+    this.configs.clear();
+  }
+  /**
+   * Clear configurations for a specific tenant
+   */
+  clearByTenant(tenantId) {
+    for (const key of this.configs.keys()) {
+      if (key.startsWith(`${tenantId}:`)) {
+        this.configs.delete(key);
+      }
+    }
+  }
+};
+
 // src/store_lattice/StoreLatticeManager.ts
 var StoreLatticeManager = class _StoreLatticeManager extends BaseLatticeManager {
   /**
@@ -3695,6 +3978,9 @@ var getStoreLattice = (key, type) => storeLatticeManager.getStoreLattice(key, ty
 var defaultThreadStore = new InMemoryThreadStore();
 var defaultAssistantStore = new InMemoryAssistantStore();
 var defaultSkillStore = new FileSystemSkillStore();
+var defaultWorkspaceStore = new InMemoryWorkspaceStore();
+var defaultProjectStore = new InMemoryProjectStore();
+var defaultDatabaseConfigStore = new InMemoryDatabaseConfigStore();
 storeLatticeManager.registerLattice("default", "thread", defaultThreadStore);
 storeLatticeManager.registerLattice(
   "default",
@@ -3702,6 +3988,9 @@ storeLatticeManager.registerLattice(
   defaultAssistantStore
 );
 storeLatticeManager.registerLattice("default", "skill", defaultSkillStore);
+storeLatticeManager.registerLattice("default", "workspace", defaultWorkspaceStore);
+storeLatticeManager.registerLattice("default", "project", defaultProjectStore);
+storeLatticeManager.registerLattice("default", "database", defaultDatabaseConfigStore);
 
 // src/tool_lattice/skill/load_skills.ts
 import z32 from "zod";
@@ -3798,6 +4087,7 @@ var DEFAULT_EXTRA_NOTE = "Use the load_skill_content tool when you need detailed
 function createSkillMiddleware(params = {}) {
   const {
     skills = [],
+    readAll = false,
     heading = DEFAULT_HEADING,
     extraNote = DEFAULT_EXTRA_NOTE
   } = params;
@@ -3805,14 +4095,16 @@ function createSkillMiddleware(params = {}) {
   return createMiddleware4({
     name: "skillMiddleware",
     tools: [
-      createLoadSkillsTool({ skills }),
+      createLoadSkillsTool({ skills: readAll ? void 0 : skills }),
       createLoadSkillContentTool()
     ],
     beforeAgent: async () => {
       try {
-        if (skills && skills.length > 0) {
-          const storeLattice = getStoreLattice("default", "skill");
-          const skillStore = storeLattice?.store;
+        const storeLattice = getStoreLattice("default", "skill");
+        const skillStore = storeLattice?.store;
+        if (readAll) {
+          latestSkills = await skillStore.getAllSkills();
+        } else if (skills && skills.length > 0) {
           const skillLatticePromises = skills.map(
             (skillId) => skillStore.getSkillById(skillId)
           );
@@ -3854,6 +4146,8 @@ import { basename } from "path";
 var EMPTY_CONTENT_WARNING = "System reminder: File exists but has empty contents";
 var MAX_LINE_LENGTH = 1e4;
 var LINE_NUMBER_WIDTH = 6;
+var TOOL_RESULT_TOKEN_LIMIT = 2e4;
+var TRUNCATION_GUIDANCE = "... [results truncated, try being more specific with your parameters]";
 function sanitizeToolCallId(toolCallId) {
   return toolCallId.replace(/\./g, "_").replace(/\//g, "_").replace(/\\/g, "_");
 }
@@ -3949,8 +4243,24 @@ function performStringReplacement(content, oldString, newString, replaceAll) {
   const newContent = content.split(oldString).join(newString);
   return [newContent, occurrences];
 }
-function validatePath(path4) {
-  const pathStr = path4 || "/";
+function truncateIfTooLong(result) {
+  if (Array.isArray(result)) {
+    const totalChars = result.reduce((sum, item) => sum + item.length, 0);
+    if (totalChars > TOOL_RESULT_TOKEN_LIMIT * 4) {
+      const truncateAt = Math.floor(
+        result.length * TOOL_RESULT_TOKEN_LIMIT * 4 / totalChars
+      );
+      return [...result.slice(0, truncateAt), TRUNCATION_GUIDANCE];
+    }
+    return result;
+  }
+  if (result.length > TOOL_RESULT_TOKEN_LIMIT * 4) {
+    return result.substring(0, TOOL_RESULT_TOKEN_LIMIT * 4) + "\n" + TRUNCATION_GUIDANCE;
+  }
+  return result;
+}
+function validatePath(path5) {
+  const pathStr = path5 || "/";
   if (!pathStr || pathStr.trim() === "") {
     throw new Error("Path cannot be empty");
   }
@@ -3960,10 +4270,10 @@ function validatePath(path4) {
   }
   return normalized;
 }
-function globSearchFiles(files, pattern, path4 = "/") {
+function globSearchFiles(files, pattern, path5 = "/") {
   let normalizedPath;
   try {
-    normalizedPath = validatePath(path4);
+    normalizedPath = validatePath(path5);
   } catch {
     return "No files found";
   }
@@ -3973,15 +4283,15 @@ function globSearchFiles(files, pattern, path4 = "/") {
   const effectivePattern = pattern;
   const matches = [];
   for (const [filePath, fileData] of Object.entries(filtered)) {
-    let relative2 = filePath.substring(normalizedPath.length);
-    if (relative2.startsWith("/")) {
-      relative2 = relative2.substring(1);
+    let relative3 = filePath.substring(normalizedPath.length);
+    if (relative3.startsWith("/")) {
+      relative3 = relative3.substring(1);
     }
-    if (!relative2) {
+    if (!relative3) {
       const parts = filePath.split("/");
-      relative2 = parts[parts.length - 1] || "";
+      relative3 = parts[parts.length - 1] || "";
     }
-    if (micromatch.isMatch(relative2, effectivePattern, {
+    if (micromatch.isMatch(relative3, effectivePattern, {
       dot: true,
       nobrace: false
     })) {
@@ -3994,7 +4304,28 @@ function globSearchFiles(files, pattern, path4 = "/") {
   }
   return matches.map(([fp]) => fp).join("\n");
 }
-function grepMatchesFromFiles(files, pattern, path4 = null, glob = null) {
+function formatGrepResults(results, outputMode) {
+  if (outputMode === "files_with_matches") {
+    return Object.keys(results).sort().join("\n");
+  }
+  if (outputMode === "count") {
+    const lines2 = [];
+    for (const filePath of Object.keys(results).sort()) {
+      const count = results[filePath].length;
+      lines2.push(`${filePath}: ${count}`);
+    }
+    return lines2.join("\n");
+  }
+  const lines = [];
+  for (const filePath of Object.keys(results).sort()) {
+    lines.push(`${filePath}:`);
+    for (const [lineNum, line] of results[filePath]) {
+      lines.push(`  ${lineNum}: ${line}`);
+    }
+  }
+  return lines.join("\n");
+}
+function grepSearchFiles(files, pattern, path5 = null, glob = null, outputMode = "files_with_matches") {
   let regex;
   try {
     regex = new RegExp(pattern);
@@ -4003,9 +4334,9 @@ function grepMatchesFromFiles(files, pattern, path4 = null, glob = null) {
   }
   let normalizedPath;
   try {
-    normalizedPath = validatePath(path4);
+    normalizedPath = validatePath(path5);
   } catch {
-    return [];
+    return "No matches found";
   }
   let filtered = Object.fromEntries(
     Object.entries(files).filter(([fp]) => fp.startsWith(normalizedPath))
@@ -4017,49 +4348,106 @@ function grepMatchesFromFiles(files, pattern, path4 = null, glob = null) {
       )
     );
   }
-  const matches = [];
+  const results = {};
   for (const [filePath, fileData] of Object.entries(filtered)) {
     for (let i = 0; i < fileData.content.length; i++) {
       const line = fileData.content[i];
       const lineNum = i + 1;
       if (regex.test(line)) {
-        matches.push({ path: filePath, line: lineNum, text: line });
+        if (!results[filePath]) {
+          results[filePath] = [];
+        }
+        results[filePath].push([lineNum, line]);
       }
     }
   }
-  return matches;
-}
-
-// src/deep_agent_new/backends/state.ts
-var StateBackend = class {
-  constructor(stateAndStore) {
-    this.stateAndStore = stateAndStore;
+  if (Object.keys(results).length === 0) {
+    return "No matches found";
   }
-  /**
-   * Get files from current state.
-   */
-  getFiles() {
-    return this.stateAndStore.state.files || {};
+  return formatGrepResults(results, outputMode);
+}
+function grepMatchesFromFiles(files, pattern, path5 = null, glob = null) {
+  let regex;
+  try {
+    regex = new RegExp(pattern);
+  } catch (e) {
+    return `Invalid regex pattern: ${e.message}`;
   }
-  /**
+  let normalizedPath;
+  try {
+    normalizedPath = validatePath(path5);
+  } catch {
+    return [];
+  }
+  let filtered = Object.fromEntries(
+    Object.entries(files).filter(([fp]) => fp.startsWith(normalizedPath))
+  );
+  if (glob) {
+    filtered = Object.fromEntries(
+      Object.entries(filtered).filter(
+        ([fp]) => micromatch.isMatch(basename(fp), glob, { dot: true, nobrace: false })
+      )
+    );
+  }
+  const matches = [];
+  for (const [filePath, fileData] of Object.entries(filtered)) {
+    for (let i = 0; i < fileData.content.length; i++) {
+      const line = fileData.content[i];
+      const lineNum = i + 1;
+      if (regex.test(line)) {
+        matches.push({ path: filePath, line: lineNum, text: line });
+      }
+    }
+  }
+  return matches;
+}
+function buildGrepResultsDict(matches) {
+  const grouped = {};
+  for (const m of matches) {
+    if (!grouped[m.path]) {
+      grouped[m.path] = [];
+    }
+    grouped[m.path].push([m.line, m.text]);
+  }
+  return grouped;
+}
+function formatGrepMatches(matches, outputMode) {
+  if (matches.length === 0) {
+    return "No matches found";
+  }
+  return formatGrepResults(buildGrepResultsDict(matches), outputMode);
+}
+
+// src/deep_agent_new/backends/state.ts
+var StateBackend = class {
+  constructor(stateAndStore) {
+    this.stateAndStore = stateAndStore;
+  }
+  /**
+   * Get files from current state.
+   */
+  getFiles() {
+    return this.stateAndStore.state.files || {};
+  }
+  /**
    * List files and directories in the specified directory (non-recursive).
    *
    * @param path - Absolute path to directory
    * @returns List of FileInfo objects for files and directories directly in the directory.
    *          Directories have a trailing / in their path and is_dir=true.
    */
-  lsInfo(path4) {
+  lsInfo(path5) {
     const files = this.getFiles();
     const infos = [];
     const subdirs = /* @__PURE__ */ new Set();
-    const normalizedPath = path4.endsWith("/") ? path4 : path4 + "/";
+    const normalizedPath = path5.endsWith("/") ? path5 : path5 + "/";
     for (const [k, fd] of Object.entries(files)) {
       if (!k.startsWith(normalizedPath)) {
         continue;
       }
-      const relative2 = k.substring(normalizedPath.length);
-      if (relative2.includes("/")) {
-        const subdirName = relative2.split("/")[0];
+      const relative3 = k.substring(normalizedPath.length);
+      if (relative3.includes("/")) {
+        const subdirName = relative3.split("/")[0];
         subdirs.add(normalizedPath + subdirName + "/");
         continue;
       }
@@ -4158,16 +4546,16 @@ var StateBackend = class {
   /**
    * Structured search results or error string for invalid input.
    */
-  grepRaw(pattern, path4 = "/", glob = null) {
+  grepRaw(pattern, path5 = "/", glob = null) {
     const files = this.getFiles();
-    return grepMatchesFromFiles(files, pattern, path4, glob);
+    return grepMatchesFromFiles(files, pattern, path5, glob);
   }
   /**
    * Structured glob matching returning FileInfo objects.
    */
-  globInfo(pattern, path4 = "/") {
+  globInfo(pattern, path5 = "/") {
     const files = this.getFiles();
-    const result = globSearchFiles(files, pattern, path4);
+    const result = globSearchFiles(files, pattern, path5);
     if (result === "No files found") {
       return [];
     }
@@ -4248,15 +4636,17 @@ function createLsTool(backend, options) {
   const { customDescription } = options;
   return tool33(
     async (input, config) => {
+      const { runConfig } = config.configurable;
       const stateAndStore = {
         state: getCurrentTaskInput(config),
-        store: config.store
+        store: config.store,
+        ...runConfig
       };
       const resolvedBackend = await getBackend(backend, stateAndStore);
-      const path4 = input.path || "/";
-      const infos = await resolvedBackend.lsInfo(path4);
+      const path5 = input.path || "/";
+      const infos = await resolvedBackend.lsInfo(path5);
       if (infos.length === 0) {
-        return `No files found in ${path4}`;
+        return `No files found in ${path5}`;
       }
       const lines = [];
       for (const info of infos) {
@@ -4282,9 +4672,11 @@ function createReadFileTool(backend, options) {
   const { customDescription } = options;
   return tool33(
     async (input, config) => {
+      const { runConfig } = config.configurable;
       const stateAndStore = {
         state: getCurrentTaskInput(config),
-        store: config.store
+        store: config.store,
+        ...runConfig
       };
       const resolvedBackend = await getBackend(backend, stateAndStore);
       const { file_path, offset = 0, limit = 2e3 } = input;
@@ -4305,9 +4697,11 @@ function createWriteFileTool(backend, options) {
   const { customDescription } = options;
   return tool33(
     async (input, config) => {
+      const { runConfig } = config.configurable;
       const stateAndStore = {
         state: getCurrentTaskInput(config),
-        store: config.store
+        store: config.store,
+        ...runConfig
       };
       const resolvedBackend = await getBackend(backend, stateAndStore);
       const { file_path, content } = input;
@@ -4342,9 +4736,11 @@ function createEditFileTool(backend, options) {
   const { customDescription } = options;
   return tool33(
     async (input, config) => {
+      const { runConfig } = config.configurable;
       const stateAndStore = {
         state: getCurrentTaskInput(config),
-        store: config.store
+        store: config.store,
+        ...runConfig
       };
       const resolvedBackend = await getBackend(backend, stateAndStore);
       const { file_path, old_string, new_string, replace_all = false } = input;
@@ -4386,13 +4782,15 @@ function createGlobTool(backend, options) {
   const { customDescription } = options;
   return tool33(
     async (input, config) => {
+      const { runConfig } = config.configurable;
       const stateAndStore = {
         state: getCurrentTaskInput(config),
-        store: config.store
+        store: config.store,
+        ...runConfig
       };
       const resolvedBackend = await getBackend(backend, stateAndStore);
-      const { pattern, path: path4 = "/" } = input;
-      const infos = await resolvedBackend.globInfo(pattern, path4);
+      const { pattern, path: path5 = "/" } = input;
+      const infos = await resolvedBackend.globInfo(pattern, path5);
       if (infos.length === 0) {
         return `No files found matching pattern '${pattern}'`;
       }
@@ -4412,13 +4810,15 @@ function createGrepTool(backend, options) {
   const { customDescription } = options;
   return tool33(
     async (input, config) => {
+      const { runConfig } = config.configurable;
       const stateAndStore = {
         state: getCurrentTaskInput(config),
-        store: config.store
+        store: config.store,
+        ...runConfig
       };
       const resolvedBackend = await getBackend(backend, stateAndStore);
-      const { pattern, path: path4 = "/", glob = null } = input;
-      const result = await resolvedBackend.grepRaw(pattern, path4, glob);
+      const { pattern, path: path5 = "/", glob = null } = input;
+      const result = await resolvedBackend.grepRaw(pattern, path5, glob);
       if (typeof result === "string") {
         return result;
       }
@@ -4588,7 +4988,22 @@ function createCommonMiddlewares(middlewareConfigs, filesystemBackend) {
         middlewares.push(createBrowserMiddleware(config.config));
         break;
       case "sql":
-        middlewares.push(createSqlMiddleware(config.config));
+        {
+          const sqlConfig = config.config;
+          if (sqlConfig.databaseKeys && sqlConfig.databaseKeys.length > 0) {
+            const databaseConfigs = global.__DATABASE_CONFIGS__ || [];
+            const descriptions = {};
+            for (const db of databaseConfigs) {
+              if (db.key && sqlConfig.databaseKeys.includes(db.key)) {
+                descriptions[db.key] = db.description || db.name || "";
+              }
+            }
+            middlewares.push(createSqlMiddleware({
+              databaseKeys: sqlConfig.databaseKeys,
+              databaseDescriptions: descriptions
+            }));
+          }
+        }
         break;
       case "skill":
         middlewares.push(createSkillMiddleware(config.config));
@@ -4607,6 +5022,7 @@ var ReActAgentGraphBuilder = class {
     }
     const isolatedLevel = filesystemConfig.config?.isolatedLevel || "global";
     return async (config) => {
+      const { workspaceId, projectId } = config;
       let sandboxName = "global";
       if (isolatedLevel === "agent") {
         sandboxName = "agent";
@@ -4618,7 +5034,8 @@ var ReActAgentGraphBuilder = class {
         throw new Error("Sandbox manager not found");
       }
       return new SandboxFilesystem({
-        sandboxInstance: await sandboxManager.createSandbox(sandboxName)
+        sandboxInstance: await sandboxManager.createSandbox(sandboxName),
+        workingDirectory: workspaceId && projectId ? `/${workspaceId}/${projectId}` : "/"
       });
     };
   }
@@ -4634,9 +5051,9 @@ var ReActAgentGraphBuilder = class {
    */
   build(agentLattice, params) {
     const tools = params.tools.map((t) => {
-      const tool36 = getToolClient(t.key);
-      return tool36;
-    }).filter((tool36) => tool36 !== void 0);
+      const tool38 = getToolClient(t.key);
+      return tool38;
+    }).filter((tool38) => tool38 !== void 0);
     const stateSchema2 = createReactAgentSchema(params.stateSchema);
     const middlewareConfigs = params.middleware || [];
     const filesystemBackend = this.createFilesystemBackendFactory(middlewareConfigs);
@@ -4937,12 +5354,12 @@ var AgentManager = class _AgentManager {
     return _AgentManager.instance;
   }
   callAgentInQueue(queue, return_agent_state) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const callback_event = `${queue.assistant_id}::${queue.thread_id}`;
       if (return_agent_state) {
         event_bus_default.subscribeOnce(callback_event, (data) => {
           if (data.success) {
-            resolve2(data.state);
+            resolve3(data.state);
           } else {
             reject(data.error);
           }
@@ -4957,7 +5374,7 @@ var AgentManager = class _AgentManager {
           },
           true
         );
-        !return_agent_state && resolve2({ callback_event_id: callback_event, success: true });
+        !return_agent_state && resolve3({ callback_event_id: callback_event, success: true });
       } catch (error) {
         !return_agent_state && reject({
           callback_event_id: callback_event,
@@ -5451,59 +5868,1144 @@ function createPatchToolCallsMiddleware() {
   });
 }
 
+// src/deep_agent_new/backends/store.ts
+var StoreBackend = class {
+  constructor(stateAndStore) {
+    this.stateAndStore = stateAndStore;
+  }
+  /**
+   * Get the store instance.
+   *
+   * @returns BaseStore instance
+   * @throws Error if no store is available
+   */
+  getStore() {
+    const store = this.stateAndStore.store;
+    if (!store) {
+      throw new Error("Store is required but not available in StateAndStore");
+    }
+    return store;
+  }
+  /**
+   * Get the namespace for store operations.
+   *
+   * If an assistant_id is available in stateAndStore, return
+   * [assistant_id, "filesystem"] to provide per-assistant isolation.
+   * Otherwise return ["filesystem"].
+   */
+  getNamespace() {
+    const namespace = "filesystem";
+    const assistantId = this.stateAndStore.assistantId;
+    if (assistantId) {
+      return [assistantId, namespace];
+    }
+    return [namespace];
+  }
+  /**
+   * Convert a store Item to FileData format.
+   *
+   * @param storeItem - The store Item containing file data
+   * @returns FileData object
+   * @throws Error if required fields are missing or have incorrect types
+   */
+  convertStoreItemToFileData(storeItem) {
+    const value = storeItem.value;
+    if (!value.content || !Array.isArray(value.content) || typeof value.created_at !== "string" || typeof value.modified_at !== "string") {
+      throw new Error(
+        `Store item does not contain valid FileData fields. Got keys: ${Object.keys(value).join(", ")}`
+      );
+    }
+    return {
+      content: value.content,
+      created_at: value.created_at,
+      modified_at: value.modified_at
+    };
+  }
+  /**
+   * Convert FileData to a value suitable for store.put().
+   *
+   * @param fileData - The FileData to convert
+   * @returns Object with content, created_at, and modified_at fields
+   */
+  convertFileDataToStoreValue(fileData) {
+    return {
+      content: fileData.content,
+      created_at: fileData.created_at,
+      modified_at: fileData.modified_at
+    };
+  }
+  /**
+   * Search store with automatic pagination to retrieve all results.
+   *
+   * @param store - The store to search
+   * @param namespace - Hierarchical path prefix to search within
+   * @param options - Optional query, filter, and page_size
+   * @returns List of all items matching the search criteria
+   */
+  async searchStorePaginated(store, namespace, options = {}) {
+    const { query, filter, pageSize = 100 } = options;
+    const allItems = [];
+    let offset = 0;
+    while (true) {
+      const pageItems = await store.search(namespace, {
+        query,
+        filter,
+        limit: pageSize,
+        offset
+      });
+      if (!pageItems || pageItems.length === 0) {
+        break;
+      }
+      allItems.push(...pageItems);
+      if (pageItems.length < pageSize) {
+        break;
+      }
+      offset += pageSize;
+    }
+    return allItems;
+  }
+  /**
+   * List files and directories in the specified directory (non-recursive).
+   *
+   * @param path - Absolute path to directory
+   * @returns List of FileInfo objects for files and directories directly in the directory.
+   *          Directories have a trailing / in their path and is_dir=true.
+   */
+  async lsInfo(path5) {
+    const store = this.getStore();
+    const namespace = this.getNamespace();
+    const items = await this.searchStorePaginated(store, namespace);
+    const infos = [];
+    const subdirs = /* @__PURE__ */ new Set();
+    const normalizedPath = path5.endsWith("/") ? path5 : path5 + "/";
+    for (const item of items) {
+      const itemKey = String(item.key);
+      if (!itemKey.startsWith(normalizedPath)) {
+        continue;
+      }
+      const relative3 = itemKey.substring(normalizedPath.length);
+      if (relative3.includes("/")) {
+        const subdirName = relative3.split("/")[0];
+        subdirs.add(normalizedPath + subdirName + "/");
+        continue;
+      }
+      try {
+        const fd = this.convertStoreItemToFileData(item);
+        const size = fd.content.join("\n").length;
+        infos.push({
+          path: itemKey,
+          is_dir: false,
+          size,
+          modified_at: fd.modified_at
+        });
+      } catch {
+        continue;
+      }
+    }
+    for (const subdir of Array.from(subdirs).sort()) {
+      infos.push({
+        path: subdir,
+        is_dir: true,
+        size: 0,
+        modified_at: ""
+      });
+    }
+    infos.sort((a, b) => a.path.localeCompare(b.path));
+    return infos;
+  }
+  /**
+   * Read file content with line numbers.
+   *
+   * @param filePath - Absolute file path
+   * @param offset - Line offset to start reading from (0-indexed)
+   * @param limit - Maximum number of lines to read
+   * @returns Formatted file content with line numbers, or error message
+   */
+  async read(filePath, offset = 0, limit = 2e3) {
+    try {
+      const fileData = await this.readRaw(filePath);
+      return formatReadResponse(fileData, offset, limit);
+    } catch (e) {
+      return `Error: ${e.message}`;
+    }
+  }
+  /**
+   * Read file content as raw FileData.
+   *
+   * @param filePath - Absolute file path
+   * @returns Raw file content as FileData
+   */
+  async readRaw(filePath) {
+    const store = this.getStore();
+    const namespace = this.getNamespace();
+    const item = await store.get(namespace, filePath);
+    if (!item) throw new Error(`File '${filePath}' not found`);
+    return this.convertStoreItemToFileData(item);
+  }
+  /**
+   * Create a new file with content.
+   * Returns WriteResult. External storage sets filesUpdate=null.
+   */
+  async write(filePath, content) {
+    const store = this.getStore();
+    const namespace = this.getNamespace();
+    const existing = await store.get(namespace, filePath);
+    if (existing) {
+      return {
+        error: `Cannot write to ${filePath} because it already exists. Read and then make an edit, or write to a new path.`
+      };
+    }
+    const fileData = createFileData(content);
+    const storeValue = this.convertFileDataToStoreValue(fileData);
+    await store.put(namespace, filePath, storeValue);
+    return { path: filePath, filesUpdate: null };
+  }
+  /**
+   * Edit a file by replacing string occurrences.
+   * Returns EditResult. External storage sets filesUpdate=null.
+   */
+  async edit(filePath, oldString, newString, replaceAll = false) {
+    const store = this.getStore();
+    const namespace = this.getNamespace();
+    const item = await store.get(namespace, filePath);
+    if (!item) {
+      return { error: `Error: File '${filePath}' not found` };
+    }
+    try {
+      const fileData = this.convertStoreItemToFileData(item);
+      const content = fileDataToString(fileData);
+      const result = performStringReplacement(
+        content,
+        oldString,
+        newString,
+        replaceAll
+      );
+      if (typeof result === "string") {
+        return { error: result };
+      }
+      const [newContent, occurrences] = result;
+      const newFileData = updateFileData(fileData, newContent);
+      const storeValue = this.convertFileDataToStoreValue(newFileData);
+      await store.put(namespace, filePath, storeValue);
+      return { path: filePath, filesUpdate: null, occurrences };
+    } catch (e) {
+      return { error: `Error: ${e.message}` };
+    }
+  }
+  /**
+   * Structured search results or error string for invalid input.
+   */
+  async grepRaw(pattern, path5 = "/", glob = null) {
+    const store = this.getStore();
+    const namespace = this.getNamespace();
+    const items = await this.searchStorePaginated(store, namespace);
+    const files = {};
+    for (const item of items) {
+      try {
+        files[item.key] = this.convertStoreItemToFileData(item);
+      } catch {
+        continue;
+      }
+    }
+    return grepMatchesFromFiles(files, pattern, path5, glob);
+  }
+  /**
+   * Structured glob matching returning FileInfo objects.
+   */
+  async globInfo(pattern, path5 = "/") {
+    const store = this.getStore();
+    const namespace = this.getNamespace();
+    const items = await this.searchStorePaginated(store, namespace);
+    const files = {};
+    for (const item of items) {
+      try {
+        files[item.key] = this.convertStoreItemToFileData(item);
+      } catch {
+        continue;
+      }
+    }
+    const result = globSearchFiles(files, pattern, path5);
+    if (result === "No files found") {
+      return [];
+    }
+    const paths = result.split("\n");
+    const infos = [];
+    for (const p of paths) {
+      const fd = files[p];
+      const size = fd ? fd.content.join("\n").length : 0;
+      infos.push({
+        path: p,
+        is_dir: false,
+        size,
+        modified_at: fd?.modified_at || ""
+      });
+    }
+    return infos;
+  }
+};
+
 // src/deep_agent_new/backends/filesystem.ts
+import * as fs2 from "fs/promises";
 import * as fsSync from "fs";
+import * as path4 from "path";
+import { spawn } from "child_process";
 import fg from "fast-glob";
 import micromatch2 from "micromatch";
 var SUPPORTS_NOFOLLOW = fsSync.constants.O_NOFOLLOW !== void 0;
-
-// src/deep_agent_new/middleware/todos.ts
-import { Command as Command3 } from "@langchain/langgraph";
-import { z as z36 } from "zod";
-import { createMiddleware as createMiddleware8, tool as tool35, ToolMessage as ToolMessage4 } from "langchain";
-var WRITE_TODOS_DESCRIPTION = `Use this tool to create and manage a structured task list for your current work session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
-It also helps the user understand the progress of the task and overall progress of their requests.
-Only use this tool if you think it will be helpful in staying organized. If the user's request is trivial and takes less than 3 steps, it is better to NOT use this tool and just do the taks directly.
-
-## When to Use This Tool
-Use this tool in these scenarios:
-
-1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
-2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
-3. User explicitly requests todo list - When the user directly asks you to use the todo list
-4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
-5. The plan may need future revisions or updates based on results from the first few steps. Keeping track of this in a list is helpful.
-
-## How to Use This Tool
-1. When you start working on a task - Mark it as in_progress BEFORE beginning work.
-2. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation.
-3. You can also update future tasks, such as deleting them if they are no longer necessary, or adding new tasks that are necessary. Don't change previously completed tasks.
-4. You can make several updates to the todo list at once. For example, when you complete a task, you can mark the next task you need to start as in_progress.
-
-## When NOT to Use This Tool
-It is important to skip using this tool when:
-1. There is only a single, straightforward task
-2. The task is trivial and tracking it provides no benefit
-3. The task can be completed in less than 3 trivial steps
-4. The task is purely conversational or informational
-
-## Examples of When to Use the Todo List
-
-<example>
-User: I want to add a dark mode toggle to the application settings. Make sure you run the tests and build when you're done!
-Assistant: I'll help add a dark mode toggle to your application settings. Let me create a todo list to track this implementation.
-*Creates todo list with the following items:*
-1. Create dark mode toggle component in Settings page
-2. Add dark mode state management (context/store)
-3. Implement CSS-in-JS styles for dark theme
-4. Update existing components to support theme switching
-5. Run tests and build process, addressing any failures or errors that occur
-*Begins working on the first task*
-
-<reasoning>
-The assistant used the todo list because:
-1. Adding dark mode in it of itself is a multi-step feature requiring UI, state management, and styling changes
-2. The assistant inferred that tests and build need to pass by adding "Ensure tests and build succeed" as the final task
+var FilesystemBackend = class {
+  constructor(options = {}) {
+    const { rootDir, virtualMode = false, maxFileSizeMb = 10 } = options;
+    this.cwd = rootDir ? path4.resolve(rootDir) : process.cwd();
+    this.virtualMode = virtualMode;
+    this.maxFileSizeBytes = maxFileSizeMb * 1024 * 1024;
+  }
+  /**
+   * Resolve a file path with security checks.
+   *
+   * When virtualMode=true, treat incoming paths as virtual absolute paths under
+   * this.cwd, disallow traversal (.., ~) and ensure resolved path stays within root.
+   * When virtualMode=false, preserve legacy behavior: absolute paths are allowed
+   * as-is; relative paths resolve under cwd.
+   *
+   * @param key - File path (absolute, relative, or virtual when virtualMode=true)
+   * @returns Resolved absolute path string
+   * @throws Error if path traversal detected or path outside root
+   */
+  resolvePath(key) {
+    if (this.virtualMode) {
+      const vpath = key.startsWith("/") ? key : "/" + key;
+      if (vpath.includes("..") || vpath.startsWith("~")) {
+        throw new Error("Path traversal not allowed");
+      }
+      const full = path4.resolve(this.cwd, vpath.substring(1));
+      const relative3 = path4.relative(this.cwd, full);
+      if (relative3.startsWith("..") || path4.isAbsolute(relative3)) {
+        throw new Error(`Path: ${full} outside root directory: ${this.cwd}`);
+      }
+      return full;
+    }
+    if (path4.isAbsolute(key)) {
+      return key;
+    }
+    return path4.resolve(this.cwd, key);
+  }
+  /**
+   * List files and directories in the specified directory (non-recursive).
+   *
+   * @param dirPath - Absolute directory path to list files from
+   * @returns List of FileInfo objects for files and directories directly in the directory.
+   *          Directories have a trailing / in their path and is_dir=true.
+   */
+  async lsInfo(dirPath) {
+    try {
+      const resolvedPath = this.resolvePath(dirPath);
+      const stat3 = await fs2.stat(resolvedPath);
+      if (!stat3.isDirectory()) {
+        return [];
+      }
+      const entries = await fs2.readdir(resolvedPath, { withFileTypes: true });
+      const results = [];
+      const cwdStr = this.cwd.endsWith(path4.sep) ? this.cwd : this.cwd + path4.sep;
+      for (const entry of entries) {
+        const fullPath = path4.join(resolvedPath, entry.name);
+        try {
+          const entryStat = await fs2.stat(fullPath);
+          const isFile = entryStat.isFile();
+          const isDir = entryStat.isDirectory();
+          if (!this.virtualMode) {
+            if (isFile) {
+              results.push({
+                path: fullPath,
+                is_dir: false,
+                size: entryStat.size,
+                modified_at: entryStat.mtime.toISOString()
+              });
+            } else if (isDir) {
+              results.push({
+                path: fullPath + path4.sep,
+                is_dir: true,
+                size: 0,
+                modified_at: entryStat.mtime.toISOString()
+              });
+            }
+          } else {
+            let relativePath;
+            if (fullPath.startsWith(cwdStr)) {
+              relativePath = fullPath.substring(cwdStr.length);
+            } else if (fullPath.startsWith(this.cwd)) {
+              relativePath = fullPath.substring(this.cwd.length).replace(/^[/\\]/, "");
+            } else {
+              relativePath = fullPath;
+            }
+            relativePath = relativePath.split(path4.sep).join("/");
+            const virtPath = "/" + relativePath;
+            if (isFile) {
+              results.push({
+                path: virtPath,
+                is_dir: false,
+                size: entryStat.size,
+                modified_at: entryStat.mtime.toISOString()
+              });
+            } else if (isDir) {
+              results.push({
+                path: virtPath + "/",
+                is_dir: true,
+                size: 0,
+                modified_at: entryStat.mtime.toISOString()
+              });
+            }
+          }
+        } catch {
+          continue;
+        }
+      }
+      results.sort((a, b) => a.path.localeCompare(b.path));
+      return results;
+    } catch (e) {
+      console.error(`Error listing files in ${dirPath}:`, e);
+      return [];
+    }
+  }
+  /**
+   * Read file content with line numbers.
+   *
+   * @param filePath - Absolute or relative file path
+   * @param offset - Line offset to start reading from (0-indexed)
+   * @param limit - Maximum number of lines to read
+   * @returns Formatted file content with line numbers, or error message
+   */
+  async read(filePath, offset = 0, limit = 2e3) {
+    try {
+      const resolvedPath = this.resolvePath(filePath);
+      let content;
+      if (SUPPORTS_NOFOLLOW) {
+        const stat3 = await fs2.stat(resolvedPath);
+        if (!stat3.isFile()) {
+          return `Error: File '${filePath}' not found`;
+        }
+        const fd = await fs2.open(
+          resolvedPath,
+          fsSync.constants.O_RDONLY | fsSync.constants.O_NOFOLLOW
+        );
+        try {
+          content = await fd.readFile({ encoding: "utf-8" });
+        } finally {
+          await fd.close();
+        }
+      } else {
+        const stat3 = await fs2.lstat(resolvedPath);
+        if (stat3.isSymbolicLink()) {
+          return `Error: Symlinks are not allowed: ${filePath}`;
+        }
+        if (!stat3.isFile()) {
+          return `Error: File '${filePath}' not found`;
+        }
+        content = await fs2.readFile(resolvedPath, "utf-8");
+      }
+      const emptyMsg = checkEmptyContent(content);
+      if (emptyMsg) {
+        return emptyMsg;
+      }
+      const lines = content.split("\n");
+      const startIdx = offset;
+      const endIdx = Math.min(startIdx + limit, lines.length);
+      if (startIdx >= lines.length) {
+        return `Error: Line offset ${offset} exceeds file length (${lines.length} lines)`;
+      }
+      const selectedLines = lines.slice(startIdx, endIdx);
+      return formatContentWithLineNumbers(selectedLines, startIdx + 1);
+    } catch (e) {
+      return `Error reading file '${filePath}': ${e.message}`;
+    }
+  }
+  /**
+   * Read file content as raw FileData.
+   *
+   * @param filePath - Absolute file path
+   * @returns Raw file content as FileData
+   */
+  async readRaw(filePath) {
+    const resolvedPath = this.resolvePath(filePath);
+    let content;
+    let stat3;
+    if (SUPPORTS_NOFOLLOW) {
+      stat3 = await fs2.stat(resolvedPath);
+      if (!stat3.isFile()) throw new Error(`File '${filePath}' not found`);
+      const fd = await fs2.open(
+        resolvedPath,
+        fsSync.constants.O_RDONLY | fsSync.constants.O_NOFOLLOW
+      );
+      try {
+        content = await fd.readFile({ encoding: "utf-8" });
+      } finally {
+        await fd.close();
+      }
+    } else {
+      stat3 = await fs2.lstat(resolvedPath);
+      if (stat3.isSymbolicLink()) {
+        throw new Error(`Symlinks are not allowed: ${filePath}`);
+      }
+      if (!stat3.isFile()) throw new Error(`File '${filePath}' not found`);
+      content = await fs2.readFile(resolvedPath, "utf-8");
+    }
+    return {
+      content: content.split("\n"),
+      created_at: stat3.ctime.toISOString(),
+      modified_at: stat3.mtime.toISOString()
+    };
+  }
+  /**
+   * Create a new file with content.
+   * Returns WriteResult. External storage sets filesUpdate=null.
+   */
+  async write(filePath, content) {
+    try {
+      const resolvedPath = this.resolvePath(filePath);
+      try {
+        const stat3 = await fs2.lstat(resolvedPath);
+        if (stat3.isSymbolicLink()) {
+          return {
+            error: `Cannot write to ${filePath} because it is a symlink. Symlinks are not allowed.`
+          };
+        }
+        return {
+          error: `Cannot write to ${filePath} because it already exists. Read and then make an edit, or write to a new path.`
+        };
+      } catch {
+      }
+      await fs2.mkdir(path4.dirname(resolvedPath), { recursive: true });
+      if (SUPPORTS_NOFOLLOW) {
+        const flags = fsSync.constants.O_WRONLY | fsSync.constants.O_CREAT | fsSync.constants.O_TRUNC | fsSync.constants.O_NOFOLLOW;
+        const fd = await fs2.open(resolvedPath, flags, 420);
+        try {
+          await fd.writeFile(content, "utf-8");
+        } finally {
+          await fd.close();
+        }
+      } else {
+        await fs2.writeFile(resolvedPath, content, "utf-8");
+      }
+      return { path: filePath, filesUpdate: null };
+    } catch (e) {
+      return { error: `Error writing file '${filePath}': ${e.message}` };
+    }
+  }
+  /**
+   * Edit a file by replacing string occurrences.
+   * Returns EditResult. External storage sets filesUpdate=null.
+   */
+  async edit(filePath, oldString, newString, replaceAll = false) {
+    try {
+      const resolvedPath = this.resolvePath(filePath);
+      let content;
+      if (SUPPORTS_NOFOLLOW) {
+        const stat3 = await fs2.stat(resolvedPath);
+        if (!stat3.isFile()) {
+          return { error: `Error: File '${filePath}' not found` };
+        }
+        const fd = await fs2.open(
+          resolvedPath,
+          fsSync.constants.O_RDONLY | fsSync.constants.O_NOFOLLOW
+        );
+        try {
+          content = await fd.readFile({ encoding: "utf-8" });
+        } finally {
+          await fd.close();
+        }
+      } else {
+        const stat3 = await fs2.lstat(resolvedPath);
+        if (stat3.isSymbolicLink()) {
+          return { error: `Error: Symlinks are not allowed: ${filePath}` };
+        }
+        if (!stat3.isFile()) {
+          return { error: `Error: File '${filePath}' not found` };
+        }
+        content = await fs2.readFile(resolvedPath, "utf-8");
+      }
+      const result = performStringReplacement(
+        content,
+        oldString,
+        newString,
+        replaceAll
+      );
+      if (typeof result === "string") {
+        return { error: result };
+      }
+      const [newContent, occurrences] = result;
+      if (SUPPORTS_NOFOLLOW) {
+        const flags = fsSync.constants.O_WRONLY | fsSync.constants.O_TRUNC | fsSync.constants.O_NOFOLLOW;
+        const fd = await fs2.open(resolvedPath, flags);
+        try {
+          await fd.writeFile(newContent, "utf-8");
+        } finally {
+          await fd.close();
+        }
+      } else {
+        await fs2.writeFile(resolvedPath, newContent, "utf-8");
+      }
+      return { path: filePath, filesUpdate: null, occurrences };
+    } catch (e) {
+      return { error: `Error editing file '${filePath}': ${e.message}` };
+    }
+  }
+  /**
+   * Structured search results or error string for invalid input.
+   */
+  async grepRaw(pattern, dirPath = "/", glob = null) {
+    try {
+      new RegExp(pattern);
+    } catch (e) {
+      return `Invalid regex pattern: ${e.message}`;
+    }
+    let baseFull;
+    try {
+      baseFull = this.resolvePath(dirPath || ".");
+    } catch {
+      return [];
+    }
+    try {
+      await fs2.stat(baseFull);
+    } catch {
+      return [];
+    }
+    let results = await this.ripgrepSearch(pattern, baseFull, glob);
+    if (results === null) {
+      results = await this.pythonSearch(pattern, baseFull, glob);
+    }
+    const matches = [];
+    for (const [fpath, items] of Object.entries(results)) {
+      for (const [lineNum, lineText] of items) {
+        matches.push({ path: fpath, line: lineNum, text: lineText });
+      }
+    }
+    return matches;
+  }
+  /**
+   * Try to use ripgrep for fast searching.
+   * Returns null if ripgrep is not available or fails.
+   */
+  async ripgrepSearch(pattern, baseFull, includeGlob) {
+    return new Promise((resolve3) => {
+      const args = ["--json"];
+      if (includeGlob) {
+        args.push("--glob", includeGlob);
+      }
+      args.push("--", pattern, baseFull);
+      const proc = spawn("rg", args, { timeout: 3e4 });
+      const results = {};
+      let output = "";
+      proc.stdout.on("data", (data) => {
+        output += data.toString();
+      });
+      proc.on("close", (code) => {
+        if (code !== 0 && code !== 1) {
+          resolve3(null);
+          return;
+        }
+        for (const line of output.split("\n")) {
+          if (!line.trim()) continue;
+          try {
+            const data = JSON.parse(line);
+            if (data.type !== "match") continue;
+            const pdata = data.data || {};
+            const ftext = pdata.path?.text;
+            if (!ftext) continue;
+            let virtPath;
+            if (this.virtualMode) {
+              try {
+                const resolved = path4.resolve(ftext);
+                const relative3 = path4.relative(this.cwd, resolved);
+                if (relative3.startsWith("..")) continue;
+                const normalizedRelative = relative3.split(path4.sep).join("/");
+                virtPath = "/" + normalizedRelative;
+              } catch {
+                continue;
+              }
+            } else {
+              virtPath = ftext;
+            }
+            const ln = pdata.line_number;
+            const lt = pdata.lines?.text?.replace(/\n$/, "") || "";
+            if (ln === void 0) continue;
+            if (!results[virtPath]) {
+              results[virtPath] = [];
+            }
+            results[virtPath].push([ln, lt]);
+          } catch {
+            continue;
+          }
+        }
+        resolve3(results);
+      });
+      proc.on("error", () => {
+        resolve3(null);
+      });
+    });
+  }
+  /**
+   * Fallback regex search implementation.
+   */
+  async pythonSearch(pattern, baseFull, includeGlob) {
+    let regex;
+    try {
+      regex = new RegExp(pattern);
+    } catch {
+      return {};
+    }
+    const results = {};
+    const stat3 = await fs2.stat(baseFull);
+    const root = stat3.isDirectory() ? baseFull : path4.dirname(baseFull);
+    const files = await fg("**/*", {
+      cwd: root,
+      absolute: true,
+      onlyFiles: true,
+      dot: true
+    });
+    for (const fp of files) {
+      try {
+        if (includeGlob && !micromatch2.isMatch(path4.basename(fp), includeGlob)) {
+          continue;
+        }
+        const stat4 = await fs2.stat(fp);
+        if (stat4.size > this.maxFileSizeBytes) {
+          continue;
+        }
+        const content = await fs2.readFile(fp, "utf-8");
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          if (regex.test(line)) {
+            let virtPath;
+            if (this.virtualMode) {
+              try {
+                const relative3 = path4.relative(this.cwd, fp);
+                if (relative3.startsWith("..")) continue;
+                const normalizedRelative = relative3.split(path4.sep).join("/");
+                virtPath = "/" + normalizedRelative;
+              } catch {
+                continue;
+              }
+            } else {
+              virtPath = fp;
+            }
+            if (!results[virtPath]) {
+              results[virtPath] = [];
+            }
+            results[virtPath].push([i + 1, line]);
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+    return results;
+  }
+  /**
+   * Structured glob matching returning FileInfo objects.
+   */
+  async globInfo(pattern, searchPath = "/") {
+    if (pattern.startsWith("/")) {
+      pattern = pattern.substring(1);
+    }
+    const resolvedSearchPath = searchPath === "/" ? this.cwd : this.resolvePath(searchPath);
+    try {
+      const stat3 = await fs2.stat(resolvedSearchPath);
+      if (!stat3.isDirectory()) {
+        return [];
+      }
+    } catch {
+      return [];
+    }
+    const results = [];
+    try {
+      const matches = await fg(pattern, {
+        cwd: resolvedSearchPath,
+        absolute: true,
+        onlyFiles: true,
+        dot: true
+      });
+      for (const matchedPath of matches) {
+        try {
+          const stat3 = await fs2.stat(matchedPath);
+          if (!stat3.isFile()) continue;
+          const normalizedPath = matchedPath.split("/").join(path4.sep);
+          if (!this.virtualMode) {
+            results.push({
+              path: normalizedPath,
+              is_dir: false,
+              size: stat3.size,
+              modified_at: stat3.mtime.toISOString()
+            });
+          } else {
+            const cwdStr = this.cwd.endsWith(path4.sep) ? this.cwd : this.cwd + path4.sep;
+            let relativePath;
+            if (normalizedPath.startsWith(cwdStr)) {
+              relativePath = normalizedPath.substring(cwdStr.length);
+            } else if (normalizedPath.startsWith(this.cwd)) {
+              relativePath = normalizedPath.substring(this.cwd.length).replace(/^[/\\]/, "");
+            } else {
+              relativePath = normalizedPath;
+            }
+            relativePath = relativePath.split(path4.sep).join("/");
+            const virt = "/" + relativePath;
+            results.push({
+              path: virt,
+              is_dir: false,
+              size: stat3.size,
+              modified_at: stat3.mtime.toISOString()
+            });
+          }
+        } catch {
+          continue;
+        }
+      }
+    } catch {
+    }
+    results.sort((a, b) => a.path.localeCompare(b.path));
+    return results;
+  }
+};
+
+// src/deep_agent_new/backends/composite.ts
+var CompositeBackend = class {
+  constructor(defaultBackend, routes) {
+    this.default = defaultBackend;
+    this.routes = routes;
+    this.sortedRoutes = Object.entries(routes).sort(
+      (a, b) => b[0].length - a[0].length
+    );
+  }
+  /**
+   * Determine which backend handles this key and strip prefix.
+   *
+   * @param key - Original file path
+   * @returns Tuple of [backend, stripped_key] where stripped_key has the route
+   *          prefix removed (but keeps leading slash).
+   */
+  getBackendAndKey(key) {
+    for (const [prefix, backend] of this.sortedRoutes) {
+      if (key.startsWith(prefix)) {
+        const suffix = key.substring(prefix.length);
+        const strippedKey = suffix ? "/" + suffix : "/";
+        return [backend, strippedKey];
+      }
+    }
+    return [this.default, key];
+  }
+  /**
+   * List files and directories in the specified directory (non-recursive).
+   *
+   * @param path - Absolute path to directory
+   * @returns List of FileInfo objects with route prefixes added, for files and directories
+   *          directly in the directory. Directories have a trailing / in their path and is_dir=true.
+   */
+  async lsInfo(path5) {
+    for (const [routePrefix, backend] of this.sortedRoutes) {
+      if (path5.startsWith(routePrefix.replace(/\/$/, ""))) {
+        const suffix = path5.substring(routePrefix.length);
+        const searchPath = suffix ? "/" + suffix : "/";
+        const infos = await backend.lsInfo(searchPath);
+        const prefixed = [];
+        for (const fi of infos) {
+          prefixed.push({
+            ...fi,
+            path: routePrefix.slice(0, -1) + fi.path
+          });
+        }
+        return prefixed;
+      }
+    }
+    if (path5 === "/") {
+      const results = [];
+      const defaultInfos = await this.default.lsInfo(path5);
+      results.push(...defaultInfos);
+      for (const [routePrefix] of this.sortedRoutes) {
+        results.push({
+          path: routePrefix,
+          is_dir: true,
+          size: 0,
+          modified_at: ""
+        });
+      }
+      results.sort((a, b) => a.path.localeCompare(b.path));
+      return results;
+    }
+    return await this.default.lsInfo(path5);
+  }
+  /**
+   * Read file content, routing to appropriate backend.
+   *
+   * @param filePath - Absolute file path
+   * @param offset - Line offset to start reading from (0-indexed)
+   * @param limit - Maximum number of lines to read
+   * @returns Formatted file content with line numbers, or error message
+   */
+  async read(filePath, offset = 0, limit = 2e3) {
+    const [backend, strippedKey] = this.getBackendAndKey(filePath);
+    return await backend.read(strippedKey, offset, limit);
+  }
+  /**
+   * Read file content as raw FileData.
+   *
+   * @param filePath - Absolute file path
+   * @returns Raw file content as FileData
+   */
+  async readRaw(filePath) {
+    const [backend, strippedKey] = this.getBackendAndKey(filePath);
+    return await backend.readRaw(strippedKey);
+  }
+  /**
+   * Structured search results or error string for invalid input.
+   */
+  async grepRaw(pattern, path5 = "/", glob = null) {
+    for (const [routePrefix, backend] of this.sortedRoutes) {
+      if (path5.startsWith(routePrefix.replace(/\/$/, ""))) {
+        const searchPath = path5.substring(routePrefix.length - 1);
+        const raw = await backend.grepRaw(pattern, searchPath || "/", glob);
+        if (typeof raw === "string") {
+          return raw;
+        }
+        return raw.map((m) => ({
+          ...m,
+          path: routePrefix.slice(0, -1) + m.path
+        }));
+      }
+    }
+    const allMatches = [];
+    const rawDefault = await this.default.grepRaw(pattern, path5, glob);
+    if (typeof rawDefault === "string") {
+      return rawDefault;
+    }
+    allMatches.push(...rawDefault);
+    for (const [routePrefix, backend] of Object.entries(this.routes)) {
+      const raw = await backend.grepRaw(pattern, "/", glob);
+      if (typeof raw === "string") {
+        return raw;
+      }
+      allMatches.push(
+        ...raw.map((m) => ({
+          ...m,
+          path: routePrefix.slice(0, -1) + m.path
+        }))
+      );
+    }
+    return allMatches;
+  }
+  /**
+   * Structured glob matching returning FileInfo objects.
+   */
+  async globInfo(pattern, path5 = "/") {
+    const results = [];
+    for (const [routePrefix, backend] of this.sortedRoutes) {
+      if (path5.startsWith(routePrefix.replace(/\/$/, ""))) {
+        const searchPath = path5.substring(routePrefix.length - 1);
+        const infos = await backend.globInfo(pattern, searchPath || "/");
+        return infos.map((fi) => ({
+          ...fi,
+          path: routePrefix.slice(0, -1) + fi.path
+        }));
+      }
+    }
+    const defaultInfos = await this.default.globInfo(pattern, path5);
+    results.push(...defaultInfos);
+    for (const [routePrefix, backend] of Object.entries(this.routes)) {
+      const infos = await backend.globInfo(pattern, "/");
+      results.push(
+        ...infos.map((fi) => ({
+          ...fi,
+          path: routePrefix.slice(0, -1) + fi.path
+        }))
+      );
+    }
+    results.sort((a, b) => a.path.localeCompare(b.path));
+    return results;
+  }
+  /**
+   * Create a new file, routing to appropriate backend.
+   *
+   * @param filePath - Absolute file path
+   * @param content - File content as string
+   * @returns WriteResult with path or error
+   */
+  async write(filePath, content) {
+    const [backend, strippedKey] = this.getBackendAndKey(filePath);
+    return await backend.write(strippedKey, content);
+  }
+  /**
+   * Edit a file, routing to appropriate backend.
+   *
+   * @param filePath - Absolute file path
+   * @param oldString - String to find and replace
+   * @param newString - Replacement string
+   * @param replaceAll - If true, replace all occurrences
+   * @returns EditResult with path, occurrences, or error
+   */
+  async edit(filePath, oldString, newString, replaceAll = false) {
+    const [backend, strippedKey] = this.getBackendAndKey(filePath);
+    return await backend.edit(strippedKey, oldString, newString, replaceAll);
+  }
+};
+
+// src/deep_agent_new/backends/memory.ts
+var MemoryBackend = class {
+  constructor(files) {
+    this.files = files ?? /* @__PURE__ */ new Map();
+  }
+  getFiles() {
+    return Object.fromEntries(this.files);
+  }
+  lsInfo(path5) {
+    const files = this.getFiles();
+    const infos = [];
+    const subdirs = /* @__PURE__ */ new Set();
+    const normalizedPath = path5.endsWith("/") ? path5 : path5 + "/";
+    for (const [k, fd] of Object.entries(files)) {
+      if (!k.startsWith(normalizedPath)) {
+        continue;
+      }
+      const relative3 = k.substring(normalizedPath.length);
+      if (relative3.includes("/")) {
+        const subdirName = relative3.split("/")[0];
+        subdirs.add(normalizedPath + subdirName + "/");
+        continue;
+      }
+      const size = fd.content.join("\n").length;
+      infos.push({
+        path: k,
+        is_dir: false,
+        size,
+        modified_at: fd.modified_at
+      });
+    }
+    for (const subdir of Array.from(subdirs).sort()) {
+      infos.push({
+        path: subdir,
+        is_dir: true,
+        size: 0,
+        modified_at: ""
+      });
+    }
+    infos.sort((a, b) => a.path.localeCompare(b.path));
+    return infos;
+  }
+  read(filePath, offset = 0, limit = 2e3) {
+    const files = this.getFiles();
+    const fileData = files[filePath];
+    if (!fileData) {
+      return `Error: File '${filePath}' not found`;
+    }
+    return formatReadResponse(fileData, offset, limit);
+  }
+  readRaw(filePath) {
+    const fileData = this.files.get(filePath);
+    if (!fileData) {
+      throw new Error(`File '${filePath}' not found`);
+    }
+    return fileData;
+  }
+  write(filePath, content) {
+    if (this.files.has(filePath)) {
+      return {
+        error: `Cannot write to ${filePath} because it already exists. Read and then make an edit, or write to a new path.`
+      };
+    }
+    const newFileData = createFileData(content);
+    this.files.set(filePath, newFileData);
+    return { path: filePath, filesUpdate: null };
+  }
+  edit(filePath, oldString, newString, replaceAll = false) {
+    const fileData = this.files.get(filePath);
+    if (!fileData) {
+      return { error: `Error: File '${filePath}' not found` };
+    }
+    const content = fileDataToString(fileData);
+    const result = performStringReplacement(
+      content,
+      oldString,
+      newString,
+      replaceAll
+    );
+    if (typeof result === "string") {
+      return { error: result };
+    }
+    const [newContent, occurrences] = result;
+    const newFileData = updateFileData(fileData, newContent);
+    this.files.set(filePath, newFileData);
+    return { path: filePath, filesUpdate: null, occurrences };
+  }
+  grepRaw(pattern, path5 = "/", glob = null) {
+    const files = this.getFiles();
+    return grepMatchesFromFiles(files, pattern, path5, glob);
+  }
+  globInfo(pattern, path5 = "/") {
+    const files = this.getFiles();
+    const result = globSearchFiles(files, pattern, path5);
+    if (result === "No files found") {
+      return [];
+    }
+    const paths = result.split("\n");
+    const infos = [];
+    for (const p of paths) {
+      const fd = files[p];
+      const size = fd ? fd.content.join("\n").length : 0;
+      infos.push({
+        path: p,
+        is_dir: false,
+        size,
+        modified_at: fd?.modified_at || ""
+      });
+    }
+    return infos;
+  }
+};
+
+// src/deep_agent_new/middleware/todos.ts
+import { Command as Command3 } from "@langchain/langgraph";
+import { z as z36 } from "zod";
+import { createMiddleware as createMiddleware8, tool as tool35, ToolMessage as ToolMessage4 } from "langchain";
+var WRITE_TODOS_DESCRIPTION = `Use this tool to create and manage a structured task list for your current work session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
+It also helps the user understand the progress of the task and overall progress of their requests.
+Only use this tool if you think it will be helpful in staying organized. If the user's request is trivial and takes less than 3 steps, it is better to NOT use this tool and just do the taks directly.
+
+## When to Use This Tool
+Use this tool in these scenarios:
+
+1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
+2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
+3. User explicitly requests todo list - When the user directly asks you to use the todo list
+4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
+5. The plan may need future revisions or updates based on results from the first few steps. Keeping track of this in a list is helpful.
+
+## How to Use This Tool
+1. When you start working on a task - Mark it as in_progress BEFORE beginning work.
+2. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation.
+3. You can also update future tasks, such as deleting them if they are no longer necessary, or adding new tasks that are necessary. Don't change previously completed tasks.
+4. You can make several updates to the todo list at once. For example, when you complete a task, you can mark the next task you need to start as in_progress.
+
+## When NOT to Use This Tool
+It is important to skip using this tool when:
+1. There is only a single, straightforward task
+2. The task is trivial and tracking it provides no benefit
+3. The task can be completed in less than 3 trivial steps
+4. The task is purely conversational or informational
+
+## Examples of When to Use the Todo List
+
+<example>
+User: I want to add a dark mode toggle to the application settings. Make sure you run the tests and build when you're done!
+Assistant: I'll help add a dark mode toggle to your application settings. Let me create a todo list to track this implementation.
+*Creates todo list with the following items:*
+1. Create dark mode toggle component in Settings page
+2. Add dark mode state management (context/store)
+3. Implement CSS-in-JS styles for dark theme
+4. Update existing components to support theme switching
+5. Run tests and build process, addressing any failures or errors that occur
+*Begins working on the first task*
+
+<reasoning>
+The assistant used the todo list because:
+1. Adding dark mode in it of itself is a multi-step feature requiring UI, state management, and styling changes
+2. The assistant inferred that tests and build need to pass by adding "Ensure tests and build succeed" as the final task
 3. Both of the user's requests are complex and require multiple steps to complete.
 </reasoning>
 </example>
@@ -5609,289 +7111,1896 @@ Assistant: I'll check the current time in Tokyo for you.
 
 *Searches for current time in Tokyo*
 
-The current time in Tokyo, Japan is [current time]. Tokyo is in the Japan Standard Time (JST) zone, which is UTC+9.
+The current time in Tokyo, Japan is [current time]. Tokyo is in the Japan Standard Time (JST) zone, which is UTC+9.
+
+<reasoning>
+The assistant did not use the todo list because this is a single information lookup with immediate results. There are no multiple steps to track or organize, making the todo list unnecessary for this straightforward request.
+</reasoning>
+</example>
+
+<example>
+User: I need to write a function that checks if a number is prime and then test it out.
+Assistant: I'll help you write a function that checks if a number is prime and then test it out.
+*Writes function that checks if a number is prime*
+*Tests the function*
+
+<reasoning>
+Even though this is a multi-step task, it is very straightforward and can be completed in two trivial steps (which is less than 3 steps!). Using the todo list here is overkill and wastes time and tokens.
+</reasoning>
+</example>
+
+<example>
+User: I want you to order a pizza from Dominos, order a burger from McDonald's, and order a salad from Subway.
+Assistant: I'll help you order a pizza from Dominos, order a burger from McDonald's, and order a salad from Subway.
+*Orders a pizza from Dominos*
+*Orders a burger from McDonald's*
+*Orders a salad from Subway*
+
+<reasoning>
+Even though this is a multi-step task, assuming the assistant has the ability to order from these restaurants, it is very straightforward and can be completed in three trivial tool calls. 
+Using the todo list here is overkill and wastes time and tokens. These three tool calls should be made in parallel, in fact.
+</reasoning>
+</example>
+
+
+## Task States and Management
+
+1. **Task States**: Use these states to track progress:
+   - pending: Task not yet started
+   - in_progress: Currently working on (you can have multiple tasks in_progress at a time if they are not related to each other and can be run in parallel)
+   - completed: Task finished successfully
+
+2. **Task Management**:
+   - Update task status in real-time as you work
+   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
+   - Complete current tasks before starting new ones
+   - Remove tasks that are no longer relevant from the list entirely
+   - IMPORTANT: When you write this todo list, you should mark your first task (or tasks) as in_progress immediately!.
+   - IMPORTANT: Unless all tasks are completed, you should always have at least one task in_progress to show the user that you are working on something.
+
+3. **Task Completion Requirements**:
+   - ONLY mark a task as completed when you have FULLY accomplished it
+   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress
+   - When blocked, create a new task describing what needs to be resolved
+   - Never mark a task as completed if:
+     - There are unresolved issues or errors
+     - Work is partial or incomplete
+     - You encountered blockers that prevent completion
+     - You couldn't find necessary resources or dependencies
+     - Quality standards haven't been met
+
+4. **Task Breakdown**:
+   - Create specific, actionable items
+   - Break complex tasks into smaller, manageable steps
+   - Use clear, descriptive task names
+
+Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully
+Remember: If you only need to make a few tool calls to complete a task, and it is clear what you need to do, it is better to just do the task directly and NOT call this tool at all.`;
+var TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT = `## \`write_todos\`
+
+You have access to the \`write_todos\` tool to help you manage and plan complex objectives. 
+Use this tool for complex objectives to ensure that you are tracking each necessary step and giving the user visibility into your progress.
+This tool is very helpful for planning complex objectives, and for breaking down these larger complex objectives into smaller steps.
+
+It is critical that you mark todos as completed as soon as you are done with a step. Do not batch up multiple steps before marking them as completed.
+For simple objectives that only require a few steps, it is better to just complete the objective directly and NOT use this tool.
+Writing todos takes time and tokens, use it when it is helpful for managing complex many-step problems! But not for simple few-step requests.
 
-<reasoning>
-The assistant did not use the todo list because this is a single information lookup with immediate results. There are no multiple steps to track or organize, making the todo list unnecessary for this straightforward request.
-</reasoning>
-</example>
+## Important To-Do List Usage Notes to Remember
+- The \`write_todos\` tool should never be called multiple times in parallel.
+- Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.`;
+var TodoStatus = z36.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
+var TodoSchema = z36.object({
+  content: z36.string().describe("Content of the todo item"),
+  status: TodoStatus
+});
+var stateSchema = z36.object({ todos: z36.array(TodoSchema).default([]) });
+function todoListMiddleware(options) {
+  const writeTodos = tool35(
+    ({ todos }, config) => {
+      return new Command3({
+        update: {
+          todos,
+          messages: [
+            new ToolMessage4({
+              content: genUIMarkdown("todo_list", todos),
+              tool_call_id: config.toolCall?.id
+            })
+          ]
+        }
+      });
+    },
+    {
+      name: "write_todos",
+      description: options?.toolDescription ?? WRITE_TODOS_DESCRIPTION,
+      schema: z36.object({
+        todos: z36.array(TodoSchema).describe("List of todo items to update")
+      })
+    }
+  );
+  return createMiddleware8({
+    name: "todoListMiddleware",
+    stateSchema,
+    tools: [writeTodos],
+    wrapModelCall: (request, handler) => handler({
+      ...request,
+      systemPrompt: (request.systemPrompt ? `${request.systemPrompt}
 
-<example>
-User: I need to write a function that checks if a number is prime and then test it out.
-Assistant: I'll help you write a function that checks if a number is prime and then test it out.
-*Writes function that checks if a number is prime*
-*Tests the function*
+` : "") + (options?.systemPrompt ?? TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT)
+    })
+  });
+}
 
-<reasoning>
-Even though this is a multi-step task, it is very straightforward and can be completed in two trivial steps (which is less than 3 steps!). Using the todo list here is overkill and wastes time and tokens.
-</reasoning>
-</example>
+// src/deep_agent_new/agent.ts
+var BASE_PROMPT = `In order to complete the objective that the user asks of you, you have access to a number of standard tools.`;
+function createDeepAgent(params = {}) {
+  const {
+    model = "claude-sonnet-4-5-20250929",
+    tools = [],
+    systemPrompt,
+    middleware: customMiddleware = [],
+    subagents = [],
+    responseFormat,
+    contextSchema,
+    checkpointer,
+    store,
+    backend,
+    interruptOn,
+    name,
+    skills
+  } = params;
+  const finalSystemPrompt = systemPrompt ? `${systemPrompt}
 
-<example>
-User: I want you to order a pizza from Dominos, order a burger from McDonald's, and order a salad from Subway.
-Assistant: I'll help you order a pizza from Dominos, order a burger from McDonald's, and order a salad from Subway.
-*Orders a pizza from Dominos*
-*Orders a burger from McDonald's*
-*Orders a salad from Subway*
+${BASE_PROMPT}` : BASE_PROMPT;
+  const filesystemBackend = backend ? backend : async (config) => new StateBackend(config);
+  const middleware = [
+    // Provides todo list management capabilities for tracking tasks
+    todoListMiddleware(),
+    // Enables filesystem operations and optional long-term memory storage
+    createFilesystemMiddleware({ backend: filesystemBackend }),
+    // Enables delegation to specialized subagents for complex tasks
+    createSubAgentMiddleware({
+      defaultModel: model,
+      defaultTools: tools,
+      defaultMiddleware: [
+        // Subagent middleware: Todo list management
+        todoListMiddleware(),
+        // Subagent middleware: Filesystem operations
+        createFilesystemMiddleware({
+          backend: filesystemBackend
+        }),
+        // Subagent middleware: Automatic conversation summarization when token limits are approached
+        summarizationMiddleware({
+          model,
+          trigger: { tokens: 17e4 },
+          keep: { messages: 6 }
+        }),
+        // Subagent middleware: Anthropic prompt caching for improved performance
+        anthropicPromptCachingMiddleware({
+          unsupportedModelBehavior: "ignore"
+        }),
+        // Subagent middleware: Patches tool calls for compatibility
+        createPatchToolCallsMiddleware()
+      ],
+      defaultInterruptOn: interruptOn,
+      subagents,
+      generalPurposeAgent: false
+    }),
+    // Automatically summarizes conversation history when token limits are approached
+    summarizationMiddleware({
+      model,
+      trigger: { tokens: 17e4 },
+      keep: { messages: 6 }
+    }),
+    // Enables Anthropic prompt caching for improved performance and reduced costs
+    anthropicPromptCachingMiddleware({
+      unsupportedModelBehavior: "ignore"
+    }),
+    // Patches tool calls to ensure compatibility across different model providers
+    createPatchToolCallsMiddleware()
+  ];
+  if (interruptOn) {
+    middleware.push(humanInTheLoopMiddleware2({ interruptOn }));
+  }
+  middleware.push(...customMiddleware);
+  return createAgent3({
+    model,
+    systemPrompt: finalSystemPrompt,
+    tools,
+    middleware,
+    responseFormat,
+    contextSchema,
+    checkpointer,
+    store,
+    name
+  });
+}
 
-<reasoning>
-Even though this is a multi-step task, assuming the assistant has the ability to order from these restaurants, it is very straightforward and can be completed in three trivial tool calls. 
-Using the todo list here is overkill and wastes time and tokens. These three tool calls should be made in parallel, in fact.
-</reasoning>
-</example>
+// src/agent_lattice/builders/filesystemBackend.ts
+function createFilesystemBackendFactory(middlewareConfigs) {
+  const filesystemConfig = middlewareConfigs.find((m) => m.type === "filesystem");
+  if (!filesystemConfig || !filesystemConfig.enabled) {
+    return void 0;
+  }
+  const isolatedLevel = filesystemConfig.config?.isolatedLevel || "global";
+  return async (config) => {
+    const { workspaceId, projectId } = config;
+    let sandboxName = "global";
+    if (isolatedLevel === "agent") {
+      sandboxName = "agent";
+    } else if (isolatedLevel === "thread") {
+      sandboxName = "thread";
+    }
+    const sandboxManager = sandboxLatticeManager.getSandboxLattice("default");
+    if (!sandboxManager) {
+      throw new Error("Sandbox manager not found");
+    }
+    return new SandboxFilesystem({
+      sandboxInstance: await sandboxManager.createSandbox(sandboxName),
+      workingDirectory: workspaceId && projectId ? `/workspaces/${workspaceId}/${projectId}` : "/"
+    });
+  };
+}
 
+// src/agent_lattice/builders/DeepAgentGraphBuilder.ts
+var DeepAgentGraphBuilder = class {
+  /**
+   * 根据 middleware 配置创建 middlewares
+   */
+  createMiddlewares(middlewareConfigs) {
+    return createCommonMiddlewares(middlewareConfigs);
+  }
+  /**
+   * 构建Deep Agent Graph
+   *
+   * @param agentLattice Agent Lattice对象
+   * @param params Agent构建参数
+   * @returns 返回CompiledGraph对象
+   */
+  build(agentLattice, params) {
+    const tools = params.tools.map((t) => {
+      const toolClient = getToolClient(t.key);
+      return toolClient;
+    }).filter((tool38) => tool38 !== void 0);
+    const subagents = params.subAgents.map((sa) => {
+      if (sa.client) {
+        return {
+          name: sa.config.name,
+          description: sa.config.description,
+          runnable: sa.client
+        };
+      } else {
+        const subagentClient = createAgentClientFromAgentLattice({
+          config: sa.config
+        });
+        return {
+          name: sa.config.name,
+          description: sa.config.description,
+          runnable: subagentClient
+        };
+      }
+    });
+    const middlewareConfigs = params.middleware || [];
+    const filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
+    const middlewares = this.createMiddlewares(middlewareConfigs);
+    const deepAgent = createDeepAgent({
+      tools,
+      model: params.model,
+      contextSchema: params.stateSchema,
+      systemPrompt: params.prompt,
+      subagents,
+      checkpointer: getCheckpointSaver("default"),
+      skills: params.skillCategories,
+      backend: filesystemBackend,
+      middleware: middlewares
+    });
+    return deepAgent;
+  }
+};
 
-## Task States and Management
+// src/agent_team/agent_team.ts
+import { z as z39 } from "zod/v3";
+import { createAgent as createAgent5 } from "langchain";
+
+// src/agent_team/types.ts
+var TaskStatus = /* @__PURE__ */ ((TaskStatus3) => {
+  TaskStatus3["PENDING"] = "pending";
+  TaskStatus3["CLAIMED"] = "claimed";
+  TaskStatus3["IN_PROGRESS"] = "in_progress";
+  TaskStatus3["COMPLETED"] = "completed";
+  TaskStatus3["FAILED"] = "failed";
+  return TaskStatus3;
+})(TaskStatus || {});
+var MessageType = /* @__PURE__ */ ((MessageType2) => {
+  MessageType2["DIRECT_MESSAGE"] = "direct_message";
+  MessageType2["BROADCAST"] = "broadcast";
+  MessageType2["PLAN_REQUEST"] = "plan_request";
+  MessageType2["PLAN_FEEDBACK"] = "plan_feedback";
+  MessageType2["SHUTDOWN_REQUEST"] = "shutdown_request";
+  MessageType2["SHUTDOWN_RESPONSE"] = "shutdown_response";
+  MessageType2["TASK_FEEDBACK"] = "task_feedback";
+  MessageType2["STATUS_UPDATE"] = "status_update";
+  return MessageType2;
+})(MessageType || {});
+
+// src/agent_team/stores/InMemoryTaskListStore.ts
+import { EventEmitter as EventEmitter2 } from "events";
+var InMemoryTaskListStore = class {
+  constructor() {
+    /** Map<teamId, Map<taskId, TeamTask>> */
+    this.tasks = /* @__PURE__ */ new Map();
+    /** EventEmitter for task lifecycle events */
+    this.emitter = new EventEmitter2();
+    /** Auto-incrementing ID counter */
+    this.idCounter = 0;
+    this.emitter.setMaxListeners(200);
+  }
+  // -------------------------------------------------------------------------
+  // Helpers
+  // -------------------------------------------------------------------------
+  /** Get or create the task map for a team. */
+  getTeamTasks(teamId) {
+    let map = this.tasks.get(teamId);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      this.tasks.set(teamId, map);
+    }
+    return map;
+  }
+  /** Generate a unique task ID. */
+  nextId() {
+    this.idCounter += 1;
+    return `task-${this.idCounter}`;
+  }
+  /** Emit a scoped event: `${teamId}:${event}`. */
+  emit(teamId, event, task) {
+    this.emitter.emit(`${teamId}:${event}`, task);
+  }
+  /**
+   * Resolve dependency references by task IDs.
+   */
+  resolveDependencies(teamTasks, depIds) {
+    const resolved = [];
+    for (const ref of depIds) {
+      if (teamTasks.has(ref)) {
+        resolved.push(ref);
+      }
+    }
+    return resolved;
+  }
+  /**
+   * Check whether all dependencies of a task are in COMPLETED status.
+   */
+  areDependenciesSatisfied(teamTasks, task) {
+    if (task.dependencies.length === 0) return true;
+    return task.dependencies.every((depId) => {
+      const dep = teamTasks.get(depId);
+      return dep !== void 0 && dep.status === "completed" /* COMPLETED */;
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Lifecycle
+  // -------------------------------------------------------------------------
+  async addTask(teamId, spec) {
+    const teamTasks = this.getTeamTasks(teamId);
+    if (!/^task-\d+$/.test(spec.id)) {
+      throw new Error(`Invalid task ID format: ${spec.id}. Expected format: task-01, task-02, etc.`);
+    }
+    if (teamTasks.has(spec.id)) {
+      throw new Error(`Task ID already exists: ${spec.id}`);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const task = {
+      id: spec.id,
+      title: spec.title,
+      description: spec.description,
+      assignee: spec.assignee,
+      status: "pending" /* PENDING */,
+      dependencies: spec.dependencies ? this.resolveDependencies(teamTasks, spec.dependencies) : [],
+      createdAt: now,
+      updatedAt: now
+    };
+    teamTasks.set(task.id, task);
+    this.emit(teamId, "task:added", task);
+    return task;
+  }
+  async addTasks(teamId, specs) {
+    const teamTasks = this.getTeamTasks(teamId);
+    const now = /* @__PURE__ */ new Date();
+    const created = [];
+    const seenIds = /* @__PURE__ */ new Set();
+    for (const spec of specs) {
+      if (!/^task-\d+$/.test(spec.id)) {
+        throw new Error(`Invalid task ID format: ${spec.id}. Expected format: task-01, task-02, etc.`);
+      }
+      if (seenIds.has(spec.id)) {
+        throw new Error(`Duplicate task ID: ${spec.id}`);
+      }
+      if (teamTasks.has(spec.id)) {
+        throw new Error(`Task ID already exists: ${spec.id}`);
+      }
+      seenIds.add(spec.id);
+    }
+    for (const spec of specs) {
+      const task = {
+        id: spec.id,
+        title: spec.title,
+        description: spec.description,
+        assignee: spec.assignee,
+        status: "pending" /* PENDING */,
+        dependencies: [],
+        createdAt: now,
+        updatedAt: now
+      };
+      teamTasks.set(task.id, task);
+      created.push(task);
+    }
+    for (let i = 0; i < specs.length; i++) {
+      if (specs[i].dependencies && specs[i].dependencies.length > 0) {
+        created[i].dependencies = this.resolveDependencies(
+          teamTasks,
+          specs[i].dependencies
+        );
+      }
+    }
+    for (const task of created) {
+      this.emit(teamId, "task:added", task);
+    }
+    return created;
+  }
+  async updateTask(teamId, taskId, updates) {
+    const teamTasks = this.getTeamTasks(teamId);
+    const task = teamTasks.get(taskId);
+    if (!task) return null;
+    if (updates.title !== void 0) task.title = updates.title;
+    if (updates.description !== void 0) task.description = updates.description;
+    if (updates.assignee !== void 0) task.assignee = updates.assignee;
+    if (updates.status !== void 0) task.status = updates.status;
+    if (updates.dependencies !== void 0) {
+      task.dependencies = this.resolveDependencies(teamTasks, updates.dependencies);
+    }
+    task.updatedAt = /* @__PURE__ */ new Date();
+    return task;
+  }
+  async removeTask(teamId, taskId) {
+    const teamTasks = this.getTeamTasks(teamId);
+    const task = teamTasks.get(taskId);
+    if (!task) return false;
+    teamTasks.delete(taskId);
+    this.emit(teamId, "task:removed", task);
+    return true;
+  }
+  // -------------------------------------------------------------------------
+  // Claim / Complete
+  // -------------------------------------------------------------------------
+  /**
+   * Claim a specific task by ID: set assignee to agentId and status to CLAIMED.
+   * Only succeeds if the task is PENDING and all dependencies are COMPLETED.
+   */
+  async claimTaskById(teamId, taskId, agentId) {
+    const teamTasks = this.getTeamTasks(teamId);
+    const task = teamTasks.get(taskId);
+    if (!task) return null;
+    if (task.status !== "pending" /* PENDING */) return null;
+    if (!this.areDependenciesSatisfied(teamTasks, task)) return null;
+    task.status = "claimed" /* CLAIMED */;
+    task.assignee = agentId;
+    task.updatedAt = /* @__PURE__ */ new Date();
+    this.emit(teamId, "task:claimed", task);
+    return task;
+  }
+  async completeTask(teamId, taskId, result) {
+    const teamTasks = this.getTeamTasks(teamId);
+    const task = teamTasks.get(taskId);
+    if (!task) return null;
+    task.status = "completed" /* COMPLETED */;
+    task.result = result;
+    task.updatedAt = /* @__PURE__ */ new Date();
+    this.emit(teamId, "task:completed", task);
+    return task;
+  }
+  async failTask(teamId, taskId, error) {
+    const teamTasks = this.getTeamTasks(teamId);
+    const task = teamTasks.get(taskId);
+    if (!task) return null;
+    task.status = "failed" /* FAILED */;
+    task.error = error;
+    task.updatedAt = /* @__PURE__ */ new Date();
+    this.emit(teamId, "task:failed", task);
+    return task;
+  }
+  // -------------------------------------------------------------------------
+  // Query
+  // -------------------------------------------------------------------------
+  async getTask(teamId, taskId) {
+    const teamTasks = this.tasks.get(teamId);
+    if (!teamTasks) return null;
+    return teamTasks.get(taskId) ?? null;
+  }
+  async getTasksByStatus(teamId, status) {
+    const teamTasks = this.tasks.get(teamId);
+    if (!teamTasks) return [];
+    return Array.from(teamTasks.values()).filter((t) => t.status === status);
+  }
+  async getAllTasks(teamId) {
+    const teamTasks = this.tasks.get(teamId);
+    if (!teamTasks) return [];
+    return Array.from(teamTasks.values());
+  }
+  async isAllDone(teamId) {
+    const teamTasks = this.tasks.get(teamId);
+    if (!teamTasks || teamTasks.size === 0) return true;
+    for (const task of teamTasks.values()) {
+      if (task.status === "pending" /* PENDING */ || task.status === "claimed" /* CLAIMED */ || task.status === "in_progress" /* IN_PROGRESS */) {
+        return false;
+      }
+    }
+    return true;
+  }
+  async hasClaimable(teamId) {
+    const teamTasks = this.tasks.get(teamId);
+    if (!teamTasks) return false;
+    for (const task of teamTasks.values()) {
+      if (task.status === "pending" /* PENDING */ && this.areDependenciesSatisfied(teamTasks, task)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  // -------------------------------------------------------------------------
+  // Events
+  // -------------------------------------------------------------------------
+  onTaskEvent(teamId, event, callback) {
+    this.emitter.on(`${teamId}:${event}`, callback);
+  }
+  offTaskEvent(teamId, event, callback) {
+    this.emitter.off(`${teamId}:${event}`, callback);
+  }
+  // -------------------------------------------------------------------------
+  // Utilities
+  // -------------------------------------------------------------------------
+  /** Remove all tasks for a team (useful for cleanup / testing). */
+  clearTeam(teamId) {
+    this.tasks.delete(teamId);
+  }
+  /** Remove all tasks across all teams (useful for testing). */
+  clear() {
+    this.tasks.clear();
+  }
+};
 
-1. **Task States**: Use these states to track progress:
-   - pending: Task not yet started
-   - in_progress: Currently working on (you can have multiple tasks in_progress at a time if they are not related to each other and can be run in parallel)
-   - completed: Task finished successfully
+// src/agent_team/stores/InMemoryMailboxStore.ts
+import { EventEmitter as EventEmitter3 } from "events";
+var InMemoryMailboxStore = class {
+  constructor() {
+    /** Map<teamId, Map<agentId, MailboxMessage[]>> */
+    this.messages = /* @__PURE__ */ new Map();
+    /** Map<teamId, Set<agentId>> -- registered agents for broadcast */
+    this.agents = /* @__PURE__ */ new Map();
+    /** EventEmitter for real-time message notifications */
+    this.emitter = new EventEmitter3();
+    /** Auto-incrementing message ID counter */
+    this.idCounter = 0;
+    this.emitter.setMaxListeners(200);
+  }
+  // -------------------------------------------------------------------------
+  // Helpers
+  // -------------------------------------------------------------------------
+  /** Get or create the agent message list for a team. */
+  getAgentMessages(teamId, agentId) {
+    let teamMap = this.messages.get(teamId);
+    if (!teamMap) {
+      teamMap = /* @__PURE__ */ new Map();
+      this.messages.set(teamId, teamMap);
+    }
+    let list = teamMap.get(agentId);
+    if (!list) {
+      list = [];
+      teamMap.set(agentId, list);
+    }
+    return list;
+  }
+  /** Generate a unique message ID. */
+  nextId() {
+    this.idCounter += 1;
+    return `msg-${this.idCounter}`;
+  }
+  /** Store a message and emit a real-time event for the recipient. */
+  storeAndNotify(teamId, message) {
+    const list = this.getAgentMessages(teamId, message.to);
+    list.push(message);
+    const preview = message.content.length > 80 ? message.content.slice(0, 80) + "..." : message.content;
+    console.log(
+      `[Mailbox] ${teamId} | ${message.from} \u2192 ${message.to} [${message.type}] ${message.id}: ${preview}`
+    );
+    this.emitter.emit(`${teamId}:${message.to}:message`, message);
+    this.emitter.emit(`${teamId}:message`, message);
+  }
+  // -------------------------------------------------------------------------
+  // Messaging
+  // -------------------------------------------------------------------------
+  async sendMessage(teamId, from, to, content, type = "direct_message" /* DIRECT_MESSAGE */) {
+    const message = {
+      id: this.nextId(),
+      from,
+      to,
+      content,
+      timestamp: /* @__PURE__ */ new Date(),
+      type,
+      read: false
+    };
+    this.storeAndNotify(teamId, message);
+    return message;
+  }
+  async broadcastMessage(teamId, from, content, type = "broadcast" /* BROADCAST */) {
+    const agentSet = this.agents.get(teamId);
+    if (!agentSet || agentSet.size === 0) return [];
+    const created = [];
+    for (const agentId of agentSet) {
+      if (agentId === from) continue;
+      const message = {
+        id: this.nextId(),
+        from,
+        to: agentId,
+        content,
+        timestamp: /* @__PURE__ */ new Date(),
+        type,
+        read: false
+      };
+      this.storeAndNotify(teamId, message);
+      created.push(message);
+    }
+    return created;
+  }
+  async getMessages(teamId, agentId) {
+    const teamMap = this.messages.get(teamId);
+    if (!teamMap) return [];
+    return teamMap.get(agentId) ?? [];
+  }
+  async getUnreadMessages(teamId, agentId) {
+    const all = await this.getMessages(teamId, agentId);
+    return all.filter((m) => !m.read);
+  }
+  async markAsRead(teamId, agentId, messageId) {
+    const all = await this.getMessages(teamId, agentId);
+    const msg = all.find((m) => m.id === messageId);
+    if (msg) {
+      msg.read = true;
+      console.log(
+        `[Mailbox] ${teamId} | ${agentId} marked ${messageId} as read (from: ${msg.from})`
+      );
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Agent registration
+  // -------------------------------------------------------------------------
+  async registerAgent(teamId, agentId) {
+    let agentSet = this.agents.get(teamId);
+    if (!agentSet) {
+      agentSet = /* @__PURE__ */ new Set();
+      this.agents.set(teamId, agentSet);
+    }
+    agentSet.add(agentId);
+  }
+  async unregisterAgent(teamId, agentId) {
+    const agentSet = this.agents.get(teamId);
+    if (agentSet) {
+      agentSet.delete(agentId);
+    }
+  }
+  async getRegisteredAgents(teamId) {
+    const agentSet = this.agents.get(teamId);
+    if (!agentSet) return [];
+    return Array.from(agentSet);
+  }
+  // -------------------------------------------------------------------------
+  // Events
+  // -------------------------------------------------------------------------
+  onMessage(teamId, agentId, callback) {
+    this.emitter.on(`${teamId}:${agentId}:message`, callback);
+  }
+  offMessage(teamId, agentId, callback) {
+    this.emitter.off(`${teamId}:${agentId}:message`, callback);
+  }
+  onTeamMessage(teamId, callback) {
+    this.emitter.on(`${teamId}:message`, callback);
+  }
+  offTeamMessage(teamId, callback) {
+    this.emitter.off(`${teamId}:message`, callback);
+  }
+  async getAllTeamMessages(teamId) {
+    const teamMap = this.messages.get(teamId);
+    if (!teamMap) return [];
+    const allMessages = [];
+    for (const messages of teamMap.values()) {
+      allMessages.push(...messages);
+    }
+    return allMessages.sort(
+      (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+    );
+  }
+  // -------------------------------------------------------------------------
+  // Utilities
+  // -------------------------------------------------------------------------
+  /** Remove all data for a team (messages + registrations). */
+  clearTeam(teamId) {
+    this.messages.delete(teamId);
+    this.agents.delete(teamId);
+  }
+  /** Remove all data across all teams. */
+  clear() {
+    this.messages.clear();
+    this.agents.clear();
+  }
+};
 
-2. **Task Management**:
-   - Update task status in real-time as you work
-   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
-   - Complete current tasks before starting new ones
-   - Remove tasks that are no longer relevant from the list entirely
-   - IMPORTANT: When you write this todo list, you should mark your first task (or tasks) as in_progress immediately!.
-   - IMPORTANT: Unless all tasks are completed, you should always have at least one task in_progress to show the user that you are working on something.
+// src/agent_team/middleware/team.ts
+import { z as z38 } from "zod/v3";
+import { createMiddleware as createMiddleware9, createAgent as createAgent4, tool as tool37, ToolMessage as ToolMessage6 } from "langchain";
+import { Command as Command5, getCurrentTaskInput as getCurrentTaskInput3 } from "@langchain/langgraph";
+import { v4 as uuidv4 } from "uuid";
+
+// src/agent_team/middleware/teammate_tools.ts
+import { z as z37 } from "zod/v3";
+import { tool as tool36, ToolMessage as ToolMessage5 } from "langchain";
+import { Command as Command4 } from "@langchain/langgraph";
+
+// src/agent_team/middleware/formatMessages.ts
+function formatMessagesAsMarkdown(msgs) {
+  if (msgs.length === 0) return "No unread messages.";
+  const header = `## Unread messages (${msgs.length})
+`;
+  const sections = msgs.map((m, i) => {
+    const title = `### ${i + 1}. From: **${m.from}**`;
+    const meta = `- **Type:** \`${m.type}\`
+- **Time:** ${m.timestamp.toISOString()}`;
+    const body = m.content.trim() ? `
+
+${m.content.trim()}` : "";
+    return `---
+${title}
+${meta}${body}`;
+  });
+  return header + sections.join("\n\n");
+}
 
-3. **Task Completion Requirements**:
-   - ONLY mark a task as completed when you have FULLY accomplished it
-   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress
-   - When blocked, create a new task describing what needs to be resolved
-   - Never mark a task as completed if:
-     - There are unresolved issues or errors
-     - Work is partial or incomplete
-     - You encountered blockers that prevent completion
-     - You couldn't find necessary resources or dependencies
-     - Quality standards haven't been met
+// src/agent_team/middleware/teammate_tools.ts
+function createTeammateTools(options) {
+  const { teamId, agentId, taskListStore, mailboxStore } = options;
+  const claimTaskTool = tool36(
+    async (input) => {
+      const task = await taskListStore.claimTaskById(
+        teamId,
+        input.task_id,
+        agentId
+      );
+      if (!task) {
+        return `Could not claim task "${input.task_id}". Check that it exists, is PENDING, and all its dependencies are completed. Use check_tasks to see available tasks and their status.`;
+      }
+      return `Claimed task ${task.id} "${task.title}". Focus on this task now. When done, call complete_task or fail_task with task_id "${task.id}".
+` + JSON.stringify(
+        {
+          task_id: task.id,
+          title: task.title,
+          description: task.description,
+          dependencies: task.dependencies
+        },
+        null,
+        2
+      );
+    },
+    {
+      name: "claim_task",
+      description: "Pick a task to work on by task_id. Use check_tasks first to see all tasks; then call this with the task_id you choose. The task's assignee is set to you and you should focus on that task until you complete_task or fail_task it.",
+      schema: z37.object({
+        task_id: z37.string().describe("ID of the task to claim (e.g. task-01). Use check_tasks to see IDs.")
+      })
+    }
+  );
+  const completeTaskTool = tool36(
+    async (input) => {
+      const task = await taskListStore.completeTask(
+        teamId,
+        input.task_id,
+        input.result
+      );
+      if (!task) {
+        return `Task ${input.task_id} not found.`;
+      }
+      await mailboxStore.broadcastMessage(
+        teamId,
+        agentId,
+        `Completed task ${task.id} "${task.title}": ${input.result}`,
+        "broadcast" /* BROADCAST */
+      );
+      return `Task ${task.id} "${task.title}" marked as completed.`;
+    },
+    {
+      name: "complete_task",
+      description: "Mark a claimed task as completed with a result summary. Call this after you have finished working on a task.",
+      schema: z37.object({
+        task_id: z37.string().describe("ID of the task to complete"),
+        result: z37.string().describe("Summary of the task result")
+      })
+    }
+  );
+  const failTaskTool = tool36(
+    async (input) => {
+      const task = await taskListStore.failTask(
+        teamId,
+        input.task_id,
+        input.error
+      );
+      if (!task) {
+        return `Task ${input.task_id} not found.`;
+      }
+      await mailboxStore.broadcastMessage(
+        teamId,
+        agentId,
+        `Failed task ${task.id} "${task.title}": ${input.error}`,
+        "broadcast" /* BROADCAST */
+      );
+      return `Task ${task.id} "${task.title}" marked as failed: ${input.error}`;
+    },
+    {
+      name: "fail_task",
+      description: "Mark a claimed task as failed with an error description. Call this if you cannot complete the task.",
+      schema: z37.object({
+        task_id: z37.string().describe("ID of the task to fail"),
+        error: z37.string().describe("Description of why the task failed")
+      })
+    }
+  );
+  const sendMessageTool = tool36(
+    async (input) => {
+      await mailboxStore.sendMessage(
+        teamId,
+        agentId,
+        input.to,
+        input.content,
+        "direct_message" /* DIRECT_MESSAGE */
+      );
+      return `Message sent to ${input.to}.`;
+    },
+    {
+      name: "send_message",
+      description: 'Send a message to the team lead or another teammate via the mailbox. Use "team_lead" to message the team lead. Use this to report discoveries, request guidance, or suggest new tasks.',
+      schema: z37.object({
+        to: z37.string().describe(
+          'Recipient agent name (e.g. "team_lead" or a teammate name)'
+        ),
+        content: z37.string().describe("Message content")
+      })
+    }
+  );
+  const READ_MESSAGES_TIMEOUT_MS2 = 18e4;
+  const getRelevantMessagesForState = async () => {
+    const allMsgs = await mailboxStore.getAllTeamMessages(teamId);
+    const relevantMsgs = allMsgs.filter(
+      (msg) => msg.from === agentId || msg.to === agentId
+    );
+    return relevantMsgs.map((msg) => ({
+      id: msg.id,
+      from: msg.from,
+      to: msg.to,
+      content: msg.content,
+      timestamp: msg.timestamp instanceof Date ? msg.timestamp.toISOString() : msg.timestamp,
+      type: msg.type,
+      read: msg.read
+    }));
+  };
+  const readMessagesTool = tool36(
+    async (input, config) => {
+      const formatAndMarkAsRead = async (msgs2) => {
+        for (const msg of msgs2) {
+          await mailboxStore.markAsRead(teamId, agentId, msg.id);
+        }
+        return formatMessagesAsMarkdown(msgs2);
+      };
+      let msgs = await mailboxStore.getUnreadMessages(teamId, agentId);
+      if (msgs.length > 0) {
+        const formatted2 = await formatAndMarkAsRead(msgs);
+        const relevantMsgs2 = await getRelevantMessagesForState();
+        const toolMessage2 = new ToolMessage5({
+          content: formatted2,
+          tool_call_id: config.toolCall?.id,
+          name: "read_messages"
+        });
+        return new Command4({
+          update: { team_mailbox: relevantMsgs2, messages: [toolMessage2] }
+        });
+      }
+      const messagePromise = new Promise((resolve3) => {
+        const handler = async (msg) => {
+          mailboxStore.offMessage(teamId, agentId, handler);
+          const allMsgs = await mailboxStore.getUnreadMessages(teamId, agentId);
+          resolve3(allMsgs);
+        };
+        mailboxStore.onMessage(teamId, agentId, handler);
+      });
+      const timeoutPromise = new Promise((resolve3) => {
+        setTimeout(() => resolve3([]), READ_MESSAGES_TIMEOUT_MS2);
+      });
+      msgs = await Promise.race([messagePromise, timeoutPromise]);
+      mailboxStore.offMessage(teamId, agentId, () => {
+      });
+      const relevantMsgs = await getRelevantMessagesForState();
+      if (msgs.length === 0) {
+        const toolMessage2 = new ToolMessage5({
+          content: "No unread messages.",
+          tool_call_id: config.toolCall?.id,
+          name: "read_messages"
+        });
+        return new Command4({
+          update: { team_mailbox: relevantMsgs, messages: [toolMessage2] }
+        });
+      }
+      const formatted = await formatAndMarkAsRead(msgs);
+      const toolMessage = new ToolMessage5({
+        content: formatted,
+        tool_call_id: config.toolCall?.id,
+        name: "read_messages"
+      });
+      return new Command4({
+        update: { team_mailbox: relevantMsgs, messages: [toolMessage] }
+      });
+    },
+    {
+      name: "read_messages",
+      description: "Read unread messages from the mailbox. Returns immediately if messages exist, otherwise waits for up to 3 minutes for new messages.",
+      schema: z37.object({})
+    }
+  );
+  const checkTasksTool = tool36(
+    async () => {
+      const tasks = await taskListStore.getAllTasks(teamId);
+      return formatTaskSummary(tasks);
+    },
+    {
+      name: "check_tasks",
+      description: "Use this tool to get the current status of all tasks in a team. This is your primary way to monitor task progress.",
+      schema: z37.object({})
+    }
+  );
+  const broadcastMessageTool = tool36(
+    async (input) => {
+      const allAgents = await mailboxStore.getRegisteredAgents(teamId);
+      const recipients = allAgents.filter((a) => a !== agentId);
+      const promises = recipients.map(
+        (recipient) => mailboxStore.sendMessage(
+          teamId,
+          agentId,
+          recipient,
+          input.content,
+          "broadcast" /* BROADCAST */
+        )
+      );
+      await Promise.all(promises);
+      return `Broadcast message sent to ${recipients.length} recipient(s): ${recipients.join(", ")}`;
+    },
+    {
+      name: "broadcast_message",
+      description: "Send a message to everyone in the team except yourself. Use this to share updates or information with all teammates and the team lead at once.",
+      schema: z37.object({
+        content: z37.string().describe("Message content to broadcast to others")
+      })
+    }
+  );
+  return [
+    claimTaskTool,
+    completeTaskTool,
+    failTaskTool,
+    sendMessageTool,
+    readMessagesTool,
+    checkTasksTool,
+    broadcastMessageTool
+  ];
+}
 
-4. **Task Breakdown**:
-   - Create specific, actionable items
-   - Break complex tasks into smaller, manageable steps
-   - Use clear, descriptive task names
+// src/agent_team/middleware/team.ts
+var TEAM_LEAD_AGENT_ID = "team_lead";
+var DEFAULT_POLL_INTERVAL_MS = 5e3;
+var DEFAULT_SCHEDULE_LATTICE_KEY = "default";
+var READ_MESSAGES_TIMEOUT_MS = 18e4;
+var TEAM_COMMUNICATION_NORMS = `
+### Team communication norms
+
+- **Roles**: One \`team_lead\` coordinates the work; all others are teammates. Teammates report to team_lead and collaborate with each other as needed.
+- **Notifying everyone**: When the team_lead needs to tell something to **all** teammates (e.g. "submit your plan", "plan approved", "shut down"), use \`broadcast_message\`. Do not send the same message to each teammate individually.
+- **Teammate \u2192 all**: When a teammate needs to share something with the whole team, use \`broadcast_message\`.
+- **One-to-one**: Use \`send_message\` for directed messages (e.g. teammate sending a plan to team_lead, or team_lead replying to one teammate).
+- **New tasks**: If a teammate needs **new tasks** to be created (e.g. discovered during work or scope change), they must notify the team_lead via \`send_message\` to "team_lead". Only the team_lead may add tasks via \`add_tasks\`; teammates do not create tasks themselves.
+- **Plans**: Teammates submit their execution plan to team_lead via \`send_message\` to "team_lead". Team_lead reviews and approves; no external user approval is required. Team_lead notifies all teammates of approval via \`broadcast_message\`.
+- **Shutdown \u2014 check task state first**: When anyone receives a shutdown message (from team_lead or system), they **must not** shut down immediately. First: (1) **Check current task state** via \`check_tasks\` (team_lead) or \`check_tasks\` (teammate). (2) **Discuss with the team** via \`read_messages\`, \`send_message\`, or \`broadcast_message\`: should we continue these tasks, or stop/cancel them? (3) Only after the team has agreed\u2014either to **continue** (keep working) or to **stop/delete** the remaining tasks\u2014may shutdown proceed. Team_lead must not call \`disband_team\` until task state is verified and the team has aligned; teammates must not exit until the same alignment is reached.`;
+var TEAM_SYSTEM_PROMPT = `## Agent Team
+
+You are the team_lead. You have tools to manage a team of specialized agents that work in parallel:
+
+- \`create_team\`: Create a team with initial tasks and teammates. This is **non-blocking** -- teammates start working in the background immediately, and you stay free to continue the conversation.
+- \`add_tasks\`: Add new tasks at any time. Use the optional \`assignee\` field to assign a task to a specific teammate when you need that person to do the work; otherwise teammates will claim tasks. Sleeping teammates will wake up and claim new tasks.
+- \`assign_task\`: Set a task's assignee (reassign work to a specific teammate).
+- \`set_task_status\`: Set a task's status (pending, claimed, in_progress, completed, failed). Use to reopen a task or mark it failed.
+- \`set_task_dependencies\`: Set which task IDs must complete before this task can be claimed.
+- \`check_tasks\`: See current status of all tasks (pending, in_progress, completed, failed). Call it when \`read_messages\` indicates task changes to get full details.
+- \`send_message\`: Send a message to a specific teammate (one-to-one).
+- \`read_messages\`: Read unread messages from teammates (e.g. status updates, plans, requests). Returns immediately if messages exist, otherwise waits up to 3 minutes for new messages.
+- \`broadcast_message\`: Send a message to **all** teammates at once. Use this whenever you need to notify everyone (e.g. "submit your plan", "plan approved", "shut down"). Do not send the same message to each teammate individually.
+- \`disband_team\`: Disband the team when all work is done. This notifies all teammates and cleans up resources.
+${TEAM_COMMUNICATION_NORMS}
+
+### Workflow
+
+1. Analyze the user's request and plan the initial tasks + which teammates to assign.
+2. Call \`create_team\` to create the team with tasks.
+3. **Request execution plans**: After creating the team, use \`broadcast_message\` once to tell all teammates: "Please submit your execution plan for review."
+4. **Wait for all plans**: Use \`read_messages\` until ALL teammates have submitted their plans. Do not proceed until every teammate has submitted.
+5. **Add plans to team tasks and assign to teammates (required)**:
+   - Once you have collected execution plans from **all** teammates, you **must** add them to the team task list via \`add_tasks\`. Do not skip this step.
+   - For each teammate's plan (or each step from an integrated plan), create a task with a unique \`id\` (e.g. task-01, task-02). Set \`assignee\` to the **corresponding teammate** who will execute that plan or that task (the teammate who proposed it, or the one you assign for that work).
+   - If you **integrate or synthesize** multiple plans into one coherent plan, decompose it into concrete tasks and call \`add_tasks\` with each task's \`assignee\` set to the appropriate teammate. Use \`dependencies\` if task order matters.
+   - If plans are acceptable as-is, still call \`add_tasks\` to add each teammate's execution plan as one or more tasks, with \`assignee\` set to that teammate. Then use \`broadcast_message\` (e.g. "Plan approved. Task list has been updated. You may now start working.").
+   - If you need changes, \`send_message\` to the relevant teammate(s) with feedback and wait for revised plans; only after receiving revised plans, add tasks and assignees as above, then \`broadcast_message\` approval.
+6. **Monitor execution**: Once approved, teammates will start working. Periodically call \`check_tasks\` and \`read_messages\` to monitor progress.
+7. **When teammates request new tasks**: If a teammate notifies you (via \`read_messages\`) that they need new tasks, use \`add_tasks\` to add the tasks, then use \`broadcast_message\` to notify the team that new tasks have been added (e.g. "New tasks have been added to the list. Check with check_tasks and claim as needed."). Re-run plan approval only if the new tasks change the overall plan.
+8. **When you need a specific teammate to do something**: Create a new task with \`add_tasks\` and set \`assignee\` to that teammate's name; optionally \`send_message\` to that teammate. To reassign an existing task use \`assign_task\`; to change dependencies use \`set_task_dependencies\`; to reopen or mark failed use \`set_task_status\`.
+9. Report status to the user based on \`check_tasks\` results. Proceed to final synthesis when all tasks are done.
+10. **Cleanup \u2014 only after verifying task state and team alignment**: Before shutting down the team:
+    - Call \`check_tasks\` to get the current task state. If any tasks are still **pending**, **claimed**, or **in_progress**, do **not** broadcast shutdown yet.
+    - Use \`read_messages\` and, if needed, \`send_message\` or \`broadcast_message\` to discuss with the team: should we continue these tasks or stop/cancel them?
+    - If the team agrees to continue: let them work until tasks are done, then re-check with \`check_tasks\`.
+    - If the team agrees to stop: use \`set_task_status\` to mark remaining tasks as **failed** or **completed** (with a note) as appropriate, then call \`check_tasks\` again to confirm.
+    - Only when all tasks are in a terminal state (completed/failed) and the team has aligned, use \`broadcast_message\` to notify shutdown, then call \`disband_team\`.
+
+### Important Notes
+
+- The teammates you specify in \`create_team\` are created dynamically from name, role, and description.
+- Tasks can have dependencies -- a task won't be claimable until all its dependency tasks are completed.
+- You can add tasks and communicate with teammates at any time, even while they are working.
+- **Assigning work to a teammate**: When you need a specific teammate to do something, create a new task with \`add_tasks\` and set \`assignee\`, or use \`assign_task\` to reassign an existing task. Use \`set_task_dependencies\` to change task order; use \`set_task_status\` to reopen (pending) or mark failed.
+- **New task requests**: Teammates may request new tasks via \`send_message\`. When you receive such a request, use \`add_tasks\` then notify the team via \`broadcast_message\`.
+- **Plan approval and task sync**: After collecting all teammates' execution plans, you **must** add them to the team task list via \`add_tasks\` and set \`assignee\` for each task to the corresponding teammate. Then \`broadcast_message\` to approve (e.g. "Plan approved. Task list has been updated. You may now start working."). Do not let teammates start working until you have added tasks with assignees and broadcast approval. You review and approve; no user confirmation is required.
+- **Permissions**: All teammates inherit your permission settings.
+- **Shutdown**: Only you may tell the team to shut down. Before doing so: (1) call \`check_tasks\` to verify task state; (2) if any tasks are still in progress, discuss with the team via \`read_messages\` and \`broadcast_message\`/\`send_message\` whether to continue or stop them; (3) only after aligning (continue until done, or stop/cancel tasks), use \`broadcast_message\` then \`disband_team\`. Do not disband while tasks are still pending/in_progress without team agreement.`;
+function formatTaskSummary(tasks) {
+  if (tasks.length === 0) return "No tasks in the task list.";
+  const statusCounts = {};
+  for (const t of tasks) {
+    statusCounts[t.status] = (statusCounts[t.status] || 0) + 1;
+  }
+  const taskBlocks = tasks.map((t) => {
+    let block = `## ${t.id}
+`;
+    block += `- **Status**: ${t.status.toUpperCase()}
+`;
+    block += `- **Title**: ${t.title}
+`;
+    if (t.description) block += `- **Description**: ${t.description}
+`;
+    if (t.assignee) block += `- **Assignee**: ${t.assignee}
+`;
+    if (t.dependencies.length > 0) block += `- **Dependencies**: ${t.dependencies.join(", ")}
+`;
+    if (t.result) block += `- **Result**: ${t.result.slice(0, 500)}
+`;
+    if (t.error) block += `- **Error**: ${t.error.slice(0, 500)}
+`;
+    return block;
+  });
+  const summary = Object.entries(statusCounts).map(([s, c]) => `- ${s}: ${c}`).join(" | ");
+  return `${taskBlocks.join("\n---\n\n")}
 
-Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully
-Remember: If you only need to make a few tool calls to complete a task, and it is clear what you need to do, it is better to just do the task directly and NOT call this tool at all.`;
-var TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT = `## \`write_todos\`
+## Summary
+${summary}`;
+}
+function getTeammateAssistantId(teamId, agentName) {
+  return `team:${teamId}:${agentName}`;
+}
+async function getOrCreateTeammateAgent(ctx, spec, teamTools, teamMiddleware) {
+  const cacheKey = `${ctx.teamId}:${spec.name}`;
+  let agent = ctx.agentCache.get(cacheKey);
+  if (agent) return agent;
+  const builtinTeammateTools = createTeammateTools({
+    teamId: ctx.teamId,
+    agentId: spec.name,
+    taskListStore: ctx.taskListStore,
+    mailboxStore: ctx.mailboxStore
+  });
+  const allTools = [...teamTools ?? [], ...spec.tools ?? [], ...builtinTeammateTools];
+  const others = (ctx.allTeammateSpecs ?? []).filter((s) => s.name !== spec.name).map((s) => `${s.name} (role: ${s.role}${s.description ? `; ${s.description}` : ""})`);
+  const teammatesBlock = others.length > 0 ? `
+
+Your teammates in this team (you can \`send_message\` to them):
+- team_lead (lead)
+${others.map((o) => `- ${o}`).join("\n")}
+` : "\n\nYour teammates in this team: team_lead (lead).\n";
+  const teammatePrompt = spec.systemPrompt ?? `You are a team member. Your name in this team is "${spec.name}" and your role is "${spec.role}". You work independently with your own context window.${teammatesBlock}
+${TEAM_COMMUNICATION_NORMS}
+
+Your job:
+1. First, call \`check_tasks\` to see all tasks in the team.
+2. Submit your execution plan: Use \`send_message\` to send your plan to "team_lead". Explain how you will approach the task, what steps you will take, and any dependencies or considerations.
+3. **Wait for approval**: Do NOT start working immediately. Wait for the team_lead to approve your plan via \`read_messages\`. The lead will notify the whole team (e.g. by broadcast) with a message like "Plan approved. You may now start working." Only then may you start.
+4. Only after receiving approval: Use \`check_tasks\` to see available tasks, then call \`claim_task\` with the \`task_id\` you choose. That sets the task's assignee to you; focus on that task until done.
+5. Use your tools to complete the task thoroughly.
+6. Call \`complete_task\` with a summary of your result, or \`fail_task\` if you cannot complete it.
+7. After completing a task, call \`claim_task\` again with another \`task_id\` to get the next task (only PENDING tasks whose dependencies are done can be claimed).
+8. **If you need new tasks**: If during work you discover that new tasks are needed (e.g. scope change, follow-up work), notify the team_lead via \`send_message\` to "team_lead". Describe what new tasks are needed; do not create tasks yourself. Only the team_lead adds tasks; wait for the lead to add them and broadcast before claiming new work.
+9. When no tasks are left to claim, call \`read_messages\` to wait for messages (it waits up to 3 minutes for new messages). Continue until you receive a shutdown message from the team_lead.
+10. **Shutdown \u2014 check task state and discuss first**: When you receive a shutdown message (e.g. "All tasks are complete, you may now shut down"):
+    - **Do NOT shut down immediately.** First call \`check_tasks\` to check the current task state.
+    - If there are still tasks in **pending**, **claimed**, or **in_progress**: use \`send_message\` to "team_lead" or \`broadcast_message\` to the team to discuss: "I see tasks still in progress / pending. Should we continue these or stop/cancel them before shutdown?"
+    - Wait for team alignment (from \`read_messages\`): either (a) continue working until tasks are done, or (b) team_lead confirms tasks are stopped/cancelled.
+    - Only after the team has agreed and either all your assigned work is done or tasks are explicitly stopped, then exit gracefully. Do not shut down on your own without checking task state and team agreement.
+
+Important workflow:
+- NEVER start working on tasks before the team_lead has approved (you will see "Plan approved" or similar in \`read_messages\`)
+- Always submit your plan first via \`send_message\` to "team_lead"
+- If you need new tasks, notify team_lead via \`send_message\` to "team_lead"; only the lead adds tasks
+- If you receive feedback on your plan, revise and resubmit to team_lead
+
+You have access to these tools:
+- \`claim_task\`: Pick a task by task_id to claim it (sets assignee to you; ONLY after plan is approved). Use check_tasks first.
+- \`complete_task\`: Mark a task as completed
+- \`fail_task\`: Mark a task as failed
+- \`send_message\`: Send a message to team_lead or a specific teammate
+- \`broadcast_message\`: Send a message to everyone in the team except yourself (use when sharing with the whole team)
+- \`read_messages\`: Read messages from team_lead or teammates
+- \`check_tasks\`: Get current status of all tasks in the team`;
+  const assistantId = getTeammateAssistantId(ctx.teamId, spec.name);
+  agent = createAgent4({
+    model: spec.model ?? ctx.defaultModel,
+    systemPrompt: teammatePrompt,
+    tools: allTools,
+    description: spec.description,
+    middleware: [...teamMiddleware ?? [], ...spec.middleware ?? []],
+    checkpointer: getCheckpointSaver("default")
+  });
+  registerTeammateAgent(assistantId, agent);
+  const teammateThreadId = ctx.parentThreadId ? `${ctx.parentThreadId}____${ctx.teamId}_${spec.name}` : `standalone_${ctx.teamId}_${spec.name}`;
+  const startMessage = "Start working";
+  try {
+    await agentWorkerGraph.invoke({
+      assistant_id: assistantId,
+      thread_id: teammateThreadId,
+      input: { message: startMessage, messages: [{ role: "human", content: startMessage }] }
+    });
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : "Unknown error during teammate execution";
+    await ctx.mailboxStore.sendMessage(
+      ctx.teamId,
+      spec.name,
+      TEAM_LEAD_AGENT_ID,
+      `Teammate execution failed: ${errorMsg}`,
+      "status_update" /* STATUS_UPDATE */
+    );
+  }
+  return agent;
+}
+async function spawnTeammate(options) {
+  const {
+    teamId,
+    spec,
+    allTeammateSpecs,
+    taskListStore,
+    mailboxStore,
+    defaultModel,
+    parentThreadId = "",
+    teamTools,
+    teamMiddleware
+  } = options;
+  const ctx = {
+    teamId,
+    parentThreadId,
+    taskListStore,
+    mailboxStore,
+    teammates: /* @__PURE__ */ new Map(),
+    allTeammateSpecs,
+    defaultModel,
+    pollIntervalMs: DEFAULT_POLL_INTERVAL_MS,
+    scheduleLatticeKey: DEFAULT_SCHEDULE_LATTICE_KEY,
+    agentCache: /* @__PURE__ */ new Map()
+  };
+  await getOrCreateTeammateAgent(ctx, spec, teamTools, teamMiddleware);
+}
+function createTeamMiddleware(options) {
+  const { teamConfig, taskListStore, mailboxStore } = options;
+  const defaultModel = teamConfig.model ?? "claude-sonnet-4-5-20250929";
+  const createTeamTool = tool37(
+    async (input, config) => {
+      const state = getCurrentTaskInput3();
+      if (state?.team?.teamId) {
+        const existingId = state.team.teamId;
+        const msg = new ToolMessage6({
+          content: `A team is already active (id: ${existingId}). Use this team_id for \`check_tasks\`, \`read_messages\`, \`add_tasks\`, \`send_message\`, \`assign_task\`, \`set_task_status\`, and \`set_task_dependencies\`. Do not call \`create_team\` again unless you need a fresh team for a new objective.`,
+          tool_call_id: config.toolCall?.id,
+          name: "create_team"
+        });
+        return msg;
+      }
+      const teamId = uuidv4();
+      const createdTasks = await taskListStore.addTasks(
+        teamId,
+        input.tasks.map((t) => ({
+          id: t.id,
+          title: t.title,
+          description: t.description,
+          assignee: t.assignee,
+          dependencies: t.dependencies ?? []
+        }))
+      );
+      const matchedSpecs = [];
+      const unmatchedNames = [];
+      for (const req of input.teammates) {
+        const spec = teamConfig.teammates.find(
+          (s) => s.name === req.name || s.role === req.role
+        );
+        if (spec) {
+          matchedSpecs.push(spec);
+        } else {
+          matchedSpecs.push({
+            name: req.name,
+            role: req.role,
+            description: req.description
+          });
+          unmatchedNames.push(req.name);
+        }
+      }
+      await mailboxStore.registerAgent(teamId, TEAM_LEAD_AGENT_ID);
+      for (const spec of matchedSpecs) {
+        await mailboxStore.registerAgent(teamId, spec.name);
+      }
+      const parentThreadId = config.configurable?.thread_id ?? "";
+      matchedSpecs.forEach((spec) => {
+        void spawnTeammate({
+          teamId,
+          spec,
+          allTeammateSpecs: matchedSpecs,
+          taskListStore,
+          mailboxStore,
+          defaultModel,
+          parentThreadId,
+          teamTools: teamConfig.tools,
+          teamMiddleware: teamConfig.middleware
+        });
+      });
+      const teamJson = JSON.stringify({
+        teamId,
+        teamLeadId: TEAM_LEAD_AGENT_ID,
+        teammates: matchedSpecs.map((s) => ({
+          name: s.name,
+          role: s.role,
+          description: s.description
+        })),
+        tasks: createdTasks.map((t) => ({
+          id: t.id,
+          title: t.title,
+          description: t.description,
+          status: t.status
+        }))
+      }, null, 2);
+      let summary = `Team created (id: ${teamId}):
+`;
+      summary += `- ${matchedSpecs.length} teammate(s): ${matchedSpecs.map((s) => s.name).join(", ")}
+`;
+      summary += `- ${createdTasks.length} initial task(s): ${createdTasks.map((t) => `"${t.title}"`).join(", ")}
+`;
+      if (unmatchedNames.length > 0) {
+        summary += `- Teammates created with default prompts and tools.
+`;
+      }
+      summary += `
+Teammates are now working in the background. Keep calling \`check_tasks\` and \`read_messages\` until all tasks are completed or failed.`;
+      summary += `
 
-You have access to the \`write_todos\` tool to help you manage and plan complex objectives. 
-Use this tool for complex objectives to ensure that you are tracking each necessary step and giving the user visibility into your progress.
-This tool is very helpful for planning complex objectives, and for breaking down these larger complex objectives into smaller steps.
+\`\`\`json
+${teamJson}
+\`\`\``;
+      const toolMessage = new ToolMessage6({
+        content: summary,
+        tool_call_id: config.toolCall?.id,
+        name: "create_team"
+      });
+      const teamState = {
+        teamId,
+        teamLeadId: TEAM_LEAD_AGENT_ID,
+        teammates: matchedSpecs.map((s) => ({
+          name: s.name,
+          role: s.role,
+          description: s.description
+        })),
+        tasks: createdTasks.map((t) => ({
+          id: t.id,
+          title: t.title,
+          description: t.description,
+          status: t.status
+        })),
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      return new Command5({
+        update: { team: teamState, messages: [toolMessage] }
+      });
+    },
+    {
+      name: "create_team",
+      description: `Use this tool to create a team of specialized agents (teammates) to work on complex objectives that require multiple skills or parallel execution. The team lead (you) coordinates the work, while teammates execute tasks independently.
 
-It is critical that you mark todos as completed as soon as you are done with a step. Do not batch up multiple steps before marking them as completed.
-For simple objectives that only require a few steps, it is better to just complete the objective directly and NOT use this tool.
-Writing todos takes time and tokens, use it when it is helpful for managing complex many-step problems! But not for simple few-step requests.
+When to Use This Tool
+Use this tool in these scenarios:
 
-## Important To-Do List Usage Notes to Remember
-- The \`write_todos\` tool should never be called multiple times in parallel.
-- Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.`;
-var TodoStatus = z36.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
-var TodoSchema = z36.object({
-  content: z36.string().describe("Content of the todo item"),
-  status: TodoStatus
-});
-var stateSchema = z36.object({ todos: z36.array(TodoSchema).default([]) });
-function todoListMiddleware(options) {
-  const writeTodos = tool35(
-    ({ todos }, config) => {
-      return new Command3({
+Complex multi-step objectives - When the user's goal requires breaking into multiple tasks that can be executed in parallel or sequence
+Parallel work needed - When multiple independent subtasks can be done simultaneously by different teammates
+Diverse expertise required - When the objective needs different skills (research, writing, coding, review, etc.)
+Long-running tasks - When tasks may take time and you want to monitor progress without blocking
+
+When NOT to Use This Tool
+Skip using this tool when:
+
+Simple single task - The objective can be completed in one straightforward step
+Already have an active team - A team is already running for this session. Use check_tasks and read_messages to monitor instead
+Quick question or simple request - No need to create a team for trivial tasks
+
+IMPORTANT: Task ID Format
+- Task IDs MUST follow the format: task-01, task-02, task-03, etc.
+- Each task needs a unique ID starting from task-01
+- Use sequential IDs to help track task order and dependencies
+- Example: { id: "task-01", title: "Research topic", description: "..." }
+
+IMPORTANT: Dependencies
+- Use dependencies to express which tasks must complete before others can start
+- Dependencies should reference task IDs (e.g., ["task-01"])
+- Tasks without dependencies can be worked on immediately in parallel
+
+IMPORTANT: After Creating Team
+After calling create_team, you MUST:
+1. Use read_messages to receive updates from teammates (it waits up to 3 minutes for new messages)
+2. When messages indicate task changes, call check_tasks to get full task status
+3. Continue until all tasks show "completed" or "failed"
+4. Do NOT assume tasks are done - always verify with check_tasks`,
+      schema: z38.object({
+        tasks: z38.array(
+          z38.object({
+            id: z38.string().describe("Task ID in format task-01, task-02, etc."),
+            title: z38.string().describe("Short task title"),
+            description: z38.string().describe("Detailed task description - what exactly needs to be done"),
+            dependencies: z38.array(z38.string()).optional().default([]).describe('Array of task IDs that must complete before this task (e.g. ["task-01"])')
+          })
+        ).describe("List of tasks for teammates to work on. Each task needs unique ID (task-01, task-02, etc.)."),
+        teammates: z38.array(
+          z38.object({
+            name: z38.string().describe("Teammate name (must match a pre-configured teammate type)"),
+            role: z38.string().describe("Role category (e.g. researcher, writer, coder, reviewer)"),
+            description: z38.string().describe("What this teammate will focus on - specific instructions for their work")
+          })
+        ).describe("Teammate agents to create. Each should have a clear role and focus.")
+      })
+    }
+  );
+  const resolveTeamId = () => {
+    const state = getCurrentTaskInput3();
+    if (state?.team?.teamId) return state.team.teamId;
+    throw new Error("No team_id provided and no team in state. Call create_team first.");
+  };
+  const addTasksTool = tool37(
+    async (input, config) => {
+      const teamId = resolveTeamId();
+      const created = await taskListStore.addTasks(
+        teamId,
+        input.tasks.map((t) => ({
+          id: t.id,
+          title: t.title,
+          description: t.description,
+          assignee: t.assignee,
+          dependencies: t.dependencies ?? []
+        }))
+      );
+      const summary = created.map((t) => `- ${t.id}: "${t.title}"`).join("\n");
+      return new ToolMessage6({
+        content: `Added ${created.length} task(s) to team ${teamId}:
+${summary}
+Sleeping teammates will wake up and claim these.`,
+        tool_call_id: config.toolCall?.id,
+        name: "add_tasks"
+      });
+    },
+    {
+      name: "add_tasks",
+      description: `Use this tool to add new tasks to an existing team's task list. 
+
+When to Use This Tool
+Use this tool when:
+
+User requests additional work - After the initial team was created, the user asks for more tasks
+Teammate feedback reveals new needs - A teammate's message indicates additional tasks are needed
+Scope expansion - The original objective grows and requires more subtasks
+Follow-up tasks discovered - While working, teammates discover tasks that need to be done
+
+When NOT to Use This Tool
+Skip using this tool when:
+
+No team exists - Use create_team first to create a team
+Simple message response - Just respond to teammates via send_message
+Task modification needed - Use assign_task, set_task_status, or set_task_dependencies to change existing tasks instead
+
+IMPORTANT: Task ID Format
+- New task IDs must be unique and follow format: task-01, task-02, etc.
+- If the team already has tasks (e.g., task-01, task-02), continue the sequence (task-03, task-04)
+- Check existing tasks first using check_tasks to determine the next ID
+
+IMPORTANT: Dependencies
+- Use dependencies to specify which existing tasks must complete before new tasks can start
+- Reference task IDs (e.g., ["task-01", "task-02"])
+
+IMPORTANT: Assigning to a specific teammate
+- When you need a particular teammate to do the work, set assignee to that teammate's name (e.g. assignee: "researcher"). They can then claim or see the task as assigned to them.`,
+      schema: z38.object({
+        tasks: z38.array(
+          z38.object({
+            id: z38.string().describe("Task ID in format task-01, task-02, etc. Must be unique."),
+            title: z38.string().describe("Short task title"),
+            description: z38.string().describe("Detailed task description - what needs to be done"),
+            assignee: z38.string().optional().describe("Teammate name to assign this task to (use when you need that person to do the work)"),
+            dependencies: z38.array(z38.string()).optional().default([]).describe("Array of task IDs that must complete before this task")
+          })
+        ).describe("New tasks to add to the team")
+      })
+    }
+  );
+  const assignTaskTool = tool37(
+    async (input, config) => {
+      const teamId = resolveTeamId();
+      const task = await taskListStore.updateTask(teamId, input.task_id, {
+        assignee: input.assignee
+      });
+      if (!task) {
+        return new ToolMessage6({
+          content: `Task ${input.task_id} not found in team ${teamId}.`,
+          tool_call_id: config.toolCall?.id,
+          name: "assign_task"
+        });
+      }
+      return new ToolMessage6({
+        content: `Task "${task.title}" (${task.id}) assigned to ${input.assignee}.`,
+        tool_call_id: config.toolCall?.id,
+        name: "assign_task"
+      });
+    },
+    {
+      name: "assign_task",
+      description: "Assign a task to a specific teammate. Use when you need to reassign work to a different teammate. Omit team_id to use the active team from state.",
+      schema: z38.object({
+        task_id: z38.string().describe("Task ID to assign"),
+        assignee: z38.string().describe("Teammate name to assign this task to")
+      })
+    }
+  );
+  const setTaskStatusTool = tool37(
+    async (input, config) => {
+      const teamId = resolveTeamId();
+      const task = await taskListStore.updateTask(teamId, input.task_id, {
+        status: input.status
+      });
+      if (!task) {
+        return new ToolMessage6({
+          content: `Task ${input.task_id} not found in team ${teamId}.`,
+          tool_call_id: config.toolCall?.id,
+          name: "set_task_status"
+        });
+      }
+      return new ToolMessage6({
+        content: `Task "${task.title}" (${task.id}) status set to ${input.status}.`,
+        tool_call_id: config.toolCall?.id,
+        name: "set_task_status"
+      });
+    },
+    {
+      name: "set_task_status",
+      description: "Set a task's status. Use to reopen a task (set to pending), mark as failed, or correct status. Values: pending, claimed, in_progress, completed, failed. Omit team_id to use the active team from state.",
+      schema: z38.object({
+        task_id: z38.string().describe("Task ID to update"),
+        status: z38.enum(["pending", "claimed", "in_progress", "completed", "failed"]).describe("New status for the task")
+      })
+    }
+  );
+  const setTaskDependenciesTool = tool37(
+    async (input, config) => {
+      const teamId = resolveTeamId();
+      const task = await taskListStore.updateTask(teamId, input.task_id, {
+        dependencies: input.dependencies
+      });
+      if (!task) {
+        return new ToolMessage6({
+          content: `Task ${input.task_id} not found in team ${teamId}.`,
+          tool_call_id: config.toolCall?.id,
+          name: "set_task_dependencies"
+        });
+      }
+      return new ToolMessage6({
+        content: `Task "${task.title}" (${task.id}) dependencies set to [${input.dependencies.join(", ")}].`,
+        tool_call_id: config.toolCall?.id,
+        name: "set_task_dependencies"
+      });
+    },
+    {
+      name: "set_task_dependencies",
+      description: 'Set which task IDs must complete before this task can be claimed. Pass an array of task IDs (e.g. ["task-01", "task-02"]). Use to fix task order or add/remove dependencies. Omit team_id to use the active team from state.',
+      schema: z38.object({
+        task_id: z38.string().describe("Task ID to update"),
+        dependencies: z38.array(z38.string()).describe("Task IDs that must complete before this task can be claimed")
+      })
+    }
+  );
+  const checkTasksTool = tool37(
+    async (input, config) => {
+      const teamId = resolveTeamId();
+      const tasks = await taskListStore.getAllTasks(teamId);
+      const tasksSnapshot = tasks;
+      return new Command5({
         update: {
-          todos,
-          messages: [
-            new ToolMessage4({
-              content: genUIMarkdown("todo_list", todos),
-              tool_call_id: config.toolCall?.id
+          tasks: tasksSnapshot,
+          messages: [
+            new ToolMessage6({
+              content: formatTaskSummary(tasks),
+              tool_call_id: config.toolCall?.id,
+              name: "check_tasks"
             })
           ]
         }
       });
     },
     {
-      name: "write_todos",
-      description: options?.toolDescription ?? WRITE_TODOS_DESCRIPTION,
-      schema: z36.object({
-        todos: z36.array(TodoSchema).describe("List of todo items to update")
+      name: "check_tasks",
+      description: `Use this tool to get the current status of all tasks in a team. This is your primary way to monitor teammate progress.
+
+When to Use This Tool
+Use this tool:
+
+After creating a team - Check task status after create_team to verify tasks are being worked on
+When read_messages indicates task changes - Teammates report status via messages; call check_tasks to get full task list details
+Before final synthesis - Verify all tasks are complete before reporting results to user
+
+IMPORTANT: How to Monitor
+1. Use read_messages to wait for updates from teammates (it polls internally).
+2. When you receive messages suggesting task progress or completion, call check_tasks to get the current task status.
+3. Look at each task's status: pending, in_progress, completed, or failed.
+4. NEVER assume tasks are done - always verify with check_tasks.
+
+Task Status Values:
+- pending: Task created but not yet claimed by any teammate
+- in_progress: Teammate is actively working on this task
+- completed: Task finished successfully
+- failed: Task encountered an error`,
+      schema: z38.object({
+        team_id: z38.string().optional().describe("Team ID (omit to use active team)")
       })
     }
   );
-  return createMiddleware8({
-    name: "todoListMiddleware",
-    stateSchema,
-    tools: [writeTodos],
-    wrapModelCall: (request, handler) => handler({
-      ...request,
-      systemPrompt: (request.systemPrompt ? `${request.systemPrompt}
+  const sendMessageTool = tool37(
+    async (input, config) => {
+      const teamId = resolveTeamId();
+      await mailboxStore.sendMessage(
+        teamId,
+        TEAM_LEAD_AGENT_ID,
+        input.to,
+        input.content,
+        "direct_message" /* DIRECT_MESSAGE */
+      );
+      return new ToolMessage6({
+        content: `Message sent to ${input.to}.`,
+        tool_call_id: config.toolCall?.id,
+        name: "send_message"
+      });
+    },
+    {
+      name: "send_message",
+      description: "Send a message to a specific teammate in the team. Omit team_id to use the active team from state.",
+      schema: z38.object({
+        to: z38.string().describe("Recipient teammate name"),
+        content: z38.string().describe("Message content")
+      })
+    }
+  );
+  const readMessagesTool = tool37(
+    async (input, config) => {
+      const teamId = resolveTeamId();
+      const formatAndMarkAsRead = async (msgs2) => {
+        for (const msg of msgs2) {
+          await mailboxStore.markAsRead(teamId, TEAM_LEAD_AGENT_ID, msg.id);
+        }
+        return formatMessagesAsMarkdown(msgs2);
+      };
+      const getAllTeamMessagesForState = async () => {
+        const allMsgs = await mailboxStore.getAllTeamMessages(teamId);
+        return allMsgs.map((msg) => ({
+          id: msg.id,
+          from: msg.from,
+          to: msg.to,
+          content: msg.content,
+          timestamp: msg.timestamp instanceof Date ? msg.timestamp.toISOString() : msg.timestamp,
+          type: msg.type,
+          read: msg.read
+        }));
+      };
+      let msgs = await mailboxStore.getUnreadMessages(
+        teamId,
+        TEAM_LEAD_AGENT_ID
+      );
+      if (msgs.length > 0) {
+        const formatted2 = await formatAndMarkAsRead(msgs);
+        const allTeamMessages2 = await getAllTeamMessagesForState();
+        const toolMessage2 = new ToolMessage6({
+          content: formatted2,
+          tool_call_id: config.toolCall?.id,
+          name: "read_messages"
+        });
+        return new Command5({
+          update: { team_mailbox: allTeamMessages2, messages: [toolMessage2] }
+        });
+      }
+      const messagePromise = new Promise((resolve3) => {
+        const handler = async (msg) => {
+          mailboxStore.offMessage(teamId, TEAM_LEAD_AGENT_ID, handler);
+          const allMsgs = await mailboxStore.getUnreadMessages(
+            teamId,
+            TEAM_LEAD_AGENT_ID
+          );
+          resolve3(allMsgs);
+        };
+        mailboxStore.onMessage(teamId, TEAM_LEAD_AGENT_ID, handler);
+      });
+      const timeoutPromise = new Promise((resolve3) => {
+        setTimeout(() => resolve3([]), READ_MESSAGES_TIMEOUT_MS);
+      });
+      msgs = await Promise.race([messagePromise, timeoutPromise]);
+      mailboxStore.offMessage(
+        teamId,
+        TEAM_LEAD_AGENT_ID,
+        () => {
+        }
+      );
+      const allTeamMessages = await getAllTeamMessagesForState();
+      if (msgs.length === 0) {
+        const toolMessage2 = new ToolMessage6({
+          content: "No unread messages from teammates.",
+          tool_call_id: config.toolCall?.id,
+          name: "read_messages"
+        });
+        return new Command5({
+          update: { team_mailbox: allTeamMessages, messages: [toolMessage2] }
+        });
+      }
+      const formatted = await formatAndMarkAsRead(msgs);
+      const toolMessage = new ToolMessage6({
+        content: formatted,
+        tool_call_id: config.toolCall?.id,
+        name: "read_messages"
+      });
+      return new Command5({
+        update: { team_mailbox: allTeamMessages, messages: [toolMessage] }
+      });
+    },
+    {
+      name: "read_messages",
+      description: "Read unread messages from teammates. Returns immediately if messages exist, otherwise waits for up to 3 minutes for new messages.",
+      schema: z38.object({
+        team_id: z38.string().optional().describe("Team ID (omit to use active team)")
+      })
+    }
+  );
+  const disbandTeamTool = tool37(
+    async (input, config) => {
+      const teamId = resolveTeamId();
+      await mailboxStore.broadcastMessage(
+        teamId,
+        TEAM_LEAD_AGENT_ID,
+        "All tasks are complete. You may now shut down gracefully. Thank you for your work!",
+        "shutdown_request" /* SHUTDOWN_REQUEST */
+      );
+      await new Promise((r) => setTimeout(r, 2e3));
+      return new ToolMessage6({
+        content: `Team ${teamId} has been disbanded. All teammates notified and resources cleaned up.`,
+        tool_call_id: config.toolCall?.id,
+        name: "disband_team"
+      });
+    },
+    {
+      name: "disband_team",
+      description: "Disband a team when all work is done. Before calling: (1) Call check_tasks to verify no tasks are still pending/in_progress; (2) if any are, discuss with the team via read_messages and broadcast_message/send_message whether to continue or stop/cancel them; (3) only after alignment (all tasks completed/failed or explicitly stopped), then call this tool. This will: 1) Send a shutdown message to all teammates, 2) Wait briefly for them to clean up, 3) Clear all tasks and messages. Omit team_id to use the active team from state."
+    }
+  );
+  const broadcastMessageTool = tool37(
+    async (input, config) => {
+      const teamId = resolveTeamId();
+      await mailboxStore.broadcastMessage(
+        teamId,
+        TEAM_LEAD_AGENT_ID,
+        input.content,
+        "broadcast" /* BROADCAST */
+      );
+      return new ToolMessage6({
+        content: `Broadcast message sent to all teammates.`,
+        tool_call_id: config.toolCall?.id,
+        name: "broadcast_message"
+      });
+    },
+    {
+      name: "broadcast_message",
+      description: "Send a message to all teammates at once. Use this to communicate with everyone in the team. Omit team_id to use the active team from state.",
+      schema: z38.object({
+        content: z38.string().describe("Message content to broadcast to all teammates")
+      })
+    }
+  );
+  return createMiddleware9({
+    name: "teamMiddleware",
+    tools: [
+      createTeamTool,
+      addTasksTool,
+      assignTaskTool,
+      setTaskStatusTool,
+      setTaskDependenciesTool,
+      checkTasksTool,
+      sendMessageTool,
+      readMessagesTool,
+      disbandTeamTool,
+      broadcastMessageTool
+    ],
+    wrapModelCall: async (request, handler) => {
+      const currentPrompt = request.systemPrompt || "";
+      const newPrompt = currentPrompt ? `${currentPrompt}
 
-` : "") + (options?.systemPrompt ?? TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT)
-    })
+${TEAM_SYSTEM_PROMPT}` : TEAM_SYSTEM_PROMPT;
+      return handler({
+        ...request,
+        systemPrompt: newPrompt
+      });
+    }
   });
 }
 
-// src/deep_agent_new/agent.ts
-var BASE_PROMPT = `In order to complete the objective that the user asks of you, you have access to a number of standard tools.`;
-function createDeepAgent(params = {}) {
-  const {
-    model = "claude-sonnet-4-5-20250929",
-    tools = [],
-    systemPrompt,
-    middleware: customMiddleware = [],
-    subagents = [],
-    responseFormat,
-    contextSchema,
-    checkpointer,
-    store,
-    backend,
-    interruptOn,
-    name,
-    skills
-  } = params;
-  const finalSystemPrompt = systemPrompt ? `${systemPrompt}
-
-${BASE_PROMPT}` : BASE_PROMPT;
-  const filesystemBackend = backend ? backend : async (config) => new StateBackend(config);
+// src/agent_team/agent_team.ts
+var TeammateInfoSchema = z39.object({
+  name: z39.string().describe("Teammate name"),
+  role: z39.string().describe("Role category (e.g. research, writing, review)"),
+  description: z39.string().describe("What this teammate focuses on")
+});
+var TeamTaskInfoSchema = z39.object({
+  id: z39.string(),
+  title: z39.string(),
+  description: z39.string(),
+  status: z39.string().optional()
+});
+var MailboxMessageSchema = z39.object({
+  id: z39.string().describe("Unique message identifier"),
+  from: z39.string().describe("Sender agent name"),
+  to: z39.string().describe("Recipient agent name"),
+  content: z39.string().describe("Message content"),
+  timestamp: z39.string().describe("ISO timestamp when the message was sent"),
+  type: z39.nativeEnum(MessageType).describe("Message type"),
+  read: z39.boolean().describe("Whether the recipient has read this message")
+});
+var TeamInfoSchema = z39.object({
+  teamId: z39.string().describe("Unique team identifier"),
+  teamLeadId: z39.string().default("team_lead").describe("Team lead agent ID"),
+  teammates: z39.array(TeammateInfoSchema).describe("Active teammates in this team"),
+  tasks: z39.array(TeamTaskInfoSchema).optional().describe("Initial tasks snapshot"),
+  createdAt: z39.string().optional().describe("ISO timestamp when team was created")
+});
+var TEAM_STATE_SCHEMA = z39.object({
+  team: TeamInfoSchema.optional().describe("Team info: teamId, teamLeadId, teammates, tasks. Set when create_team succeeds."),
+  tasks: z39.array(TeamTaskInfoSchema).optional().describe("Current tasks snapshot from check_tasks. Updated on each check."),
+  team_mailbox: z39.array(MailboxMessageSchema).optional().describe("All team mailbox messages for display")
+});
+var TEAM_LEAD_BASE_PROMPT = `You are a team lead that coordinates a team of specialized agents. In order to complete the objective that the user asks of you, you will need to:
+
+1. Understand the user's objective and break it into concrete tasks.
+2. Create a team by calling \`create_team\` with the tasks and teammate assignments.
+3. **While tasks are incomplete**: Use \`read_messages\` to wait for teammate updates (it waits up to 3 minutes for new messages). When messages indicate task changes, call \`check_tasks\` to get full task status. Do not assume tasks are done without checking.
+4. **Important - Message handling**: After calling \`read_messages\`, if there are unread messages from teammates (you will see them in the tool output), you MUST:
+   - Acknowledge their message
+   - If they need guidance, provide it using \`send_message\`
+   - If they reported a problem, address it (add tasks, adjust plan, etc.)
+   - If they made a discovery, incorporate it into your plan
+   Do not just read messages - always respond or take action!
+5. **Task assignment**: You can explicitly assign tasks to specific teammates via \`send_message\`, or let them self-claim from available tasks.
+6. **Plan approval** (optional): If a teammate needs approval before implementing, wait for their plan and approve/reject with feedback via \`send_message\`.
+7. Respond to the user with status updates and final results.
+8. When the user asks for changes, use \`add_tasks\`, \`assign_task\`, \`set_task_status\`, or \`set_task_dependencies\` to evolve the task list.
+9. When teammates report discoveries or problems, adjust the plan accordingly.
+10. **Cleanup**: When all tasks are done, tell teammates to shut down, then clean up the team resources.
+
+## Coordination Rules
+
+- **Single point of contact**: User only talks to YOU - you are the only interface between user and team
+- **Don't parallel implement**: Do not start working on tasks yourself while teammates are working - wait for them to finish
+- **Always verify**: Never assume tasks are done - always verify with \`check_tasks\`
+- **Permissions**: All teammates inherit your permission settings. Adjust individual teammate modes if needed after spawning.
+
+Always plan tasks with clear, actionable descriptions. Use dependencies to express ordering constraints.`;
+function createAgentTeam(config) {
+  const taskListStore = config.taskListStore ?? new InMemoryTaskListStore();
+  const mailboxStore = config.mailboxStore ?? new InMemoryMailboxStore();
+  const filesystemMiddleware = createFilesystemMiddleware({
+    backend: config.backend
+  });
+  const allMiddleware = [filesystemMiddleware, ...config.middleware ?? []];
+  const teamConfigWithFs = {
+    ...config,
+    middleware: allMiddleware
+  };
+  const teamMiddleware = createTeamMiddleware({
+    teamConfig: teamConfigWithFs,
+    taskListStore,
+    mailboxStore
+  });
   const middleware = [
-    // Provides todo list management capabilities for tracking tasks
-    todoListMiddleware(),
-    // Enables filesystem operations and optional long-term memory storage
-    createFilesystemMiddleware({ backend: filesystemBackend }),
-    // Enables delegation to specialized subagents for complex tasks
-    createSubAgentMiddleware({
-      defaultModel: model,
-      defaultTools: tools,
-      defaultMiddleware: [
-        // Subagent middleware: Todo list management
-        todoListMiddleware(),
-        // Subagent middleware: Filesystem operations
-        createFilesystemMiddleware({
-          backend: filesystemBackend
-        }),
-        // Subagent middleware: Automatic conversation summarization when token limits are approached
-        summarizationMiddleware({
-          model,
-          trigger: { tokens: 17e4 },
-          keep: { messages: 6 }
-        }),
-        // Subagent middleware: Anthropic prompt caching for improved performance
-        anthropicPromptCachingMiddleware({
-          unsupportedModelBehavior: "ignore"
-        }),
-        // Subagent middleware: Patches tool calls for compatibility
-        createPatchToolCallsMiddleware()
-      ],
-      defaultInterruptOn: interruptOn,
-      subagents,
-      generalPurposeAgent: false
-    }),
-    // Automatically summarizes conversation history when token limits are approached
-    summarizationMiddleware({
-      model,
-      trigger: { tokens: 17e4 },
-      keep: { messages: 6 }
-    }),
-    // Enables Anthropic prompt caching for improved performance and reduced costs
-    anthropicPromptCachingMiddleware({
-      unsupportedModelBehavior: "ignore"
-    }),
-    // Patches tool calls to ensure compatibility across different model providers
-    createPatchToolCallsMiddleware()
+    teamMiddleware,
+    ...allMiddleware
   ];
-  if (interruptOn) {
-    middleware.push(humanInTheLoopMiddleware2({ interruptOn }));
-  }
-  middleware.push(...customMiddleware);
-  return createAgent3({
-    model,
-    systemPrompt: finalSystemPrompt,
-    tools,
+  const systemPrompt = config.systemPrompt + "\n\n" + TEAM_LEAD_BASE_PROMPT;
+  const stateSchema2 = createReactAgentSchema(TEAM_STATE_SCHEMA);
+  return createAgent5({
+    model: config.model ?? "claude-sonnet-4-5-20250929",
+    systemPrompt,
+    tools: [],
+    // all tools come from middleware
     middleware,
-    responseFormat,
-    contextSchema,
-    checkpointer,
-    store,
-    name
+    checkpointer: config.checkpointer,
+    stateSchema: stateSchema2
   });
 }
 
-// src/agent_lattice/builders/DeepAgentGraphBuilder.ts
-var DeepAgentGraphBuilder = class {
-  /**
-   * 根据 middleware 配置创建 backend factory
-   */
-  createFilesystemBackendFactory(middlewareConfigs) {
-    const filesystemConfig = middlewareConfigs.find((m) => m.type === "filesystem");
-    if (!filesystemConfig || !filesystemConfig.enabled) {
-      return void 0;
-    }
-    const isolatedLevel = filesystemConfig.config?.isolatedLevel || "global";
-    return async (config) => {
-      let sandboxName = "global";
-      if (isolatedLevel === "agent") {
-        sandboxName = "agent";
-      } else if (isolatedLevel === "thread") {
-        sandboxName = "thread";
-      }
-      const sandboxManager = sandboxLatticeManager.getSandboxLattice("default");
-      if (!sandboxManager) {
-        throw new Error("Sandbox manager not found");
-      }
-      return new SandboxFilesystem({
-        sandboxInstance: await sandboxManager.createSandbox(sandboxName)
-      });
-    };
-  }
-  /**
-   * 根据 middleware 配置创建 middlewares
-   */
-  createMiddlewares(middlewareConfigs) {
-    return createCommonMiddlewares(middlewareConfigs);
-  }
+// src/agent_team/builders/TeamAgentGraphBuilder.ts
+var TeamAgentGraphBuilder = class {
   /**
-   * 构建Deep Agent Graph
+   * Build a Team agent from the registered AgentLattice config.
    *
-   * @param agentLattice Agent Lattice对象
-   * @param params Agent构建参数
-   * @returns 返回CompiledGraph对象
+   * @param agentLattice - The AgentLattice containing the TeamAgentConfig
+   * @param params - Build params with resolved tools and model
+   * @returns AgentClient (the TeamLead ReactAgent)
    */
   build(agentLattice, params) {
+    const config = agentLattice.config;
+    if (!isTeamAgentConfig(config)) {
+      throw new Error(
+        `TeamAgentGraphBuilder received non-TEAM config: ${config.type}`
+      );
+    }
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool36) => tool36 !== void 0);
-    const subagents = params.subAgents.map((sa) => {
-      if (sa.client) {
-        return {
-          name: sa.config.name,
-          description: sa.config.description,
-          runnable: sa.client
-        };
-      } else {
-        const subagentClient = createAgentClientFromAgentLattice({
-          config: sa.config
-        });
-        return {
-          name: sa.config.name,
-          description: sa.config.description,
-          runnable: subagentClient
-        };
-      }
+    }).filter((tool38) => tool38 !== void 0);
+    const teammates = params.subAgents.map((sa) => {
+      const baseConfig = sa.config;
+      return {
+        name: baseConfig.name,
+        role: baseConfig.name,
+        description: baseConfig.description,
+        systemPrompt: baseConfig.prompt,
+        tools
+      };
     });
     const middlewareConfigs = params.middleware || [];
-    const filesystemBackend = this.createFilesystemBackendFactory(middlewareConfigs);
-    const middlewares = this.createMiddlewares(middlewareConfigs);
-    const deepAgent = createDeepAgent({
-      tools,
+    let filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
+    const middlewares = createCommonMiddlewares(middlewareConfigs);
+    if (!filesystemBackend) {
+      filesystemBackend = async (config2) => {
+        return new StateBackend(config2);
+      };
+    }
+    const teamConfig = {
+      teammates,
+      maxConcurrency: config.maxConcurrency,
       model: params.model,
-      contextSchema: params.stateSchema,
-      systemPrompt: params.prompt,
-      subagents,
+      systemPrompt: config.prompt || void 0,
+      tools,
       checkpointer: getCheckpointSaver("default"),
-      skills: params.skillCategories,
+      scheduleLatticeKey: config.scheduleLatticeKey,
+      pollIntervalMs: config.pollIntervalMs,
       backend: filesystemBackend,
       middleware: middlewares
-    });
-    return deepAgent;
+    };
+    const teamLead = createAgentTeam(teamConfig);
+    return teamLead;
   }
 };
 
@@ -5916,6 +9025,7 @@ var AgentGraphBuilderFactory = class _AgentGraphBuilderFactory {
   registerDefaultBuilders() {
     this.builders.set(AgentType.REACT, new ReActAgentGraphBuilder());
     this.builders.set(AgentType.DEEP_AGENT, new DeepAgentGraphBuilder());
+    this.builders.set(AgentType.TEAM, new TeamAgentGraphBuilder());
   }
   /**
    * 注册自定义Builder
@@ -6127,6 +9237,32 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
     };
     this.register(config.key, agentLattice);
   }
+  /**
+   * Register a pre-built teammate agent client for dynamic team spawning.
+   * Used when spawning teammates via agentWorkerGraph - the agent must exist
+   * in the lattice before the worker invokes it.
+   *
+   * @param key Unique key (e.g. `team:${teamId}:${agentName}`)
+   * @param client Pre-built AgentClient (ReactAgent or CompiledGraph)
+   */
+  registerTeammateAgent(key, client) {
+    const agentLattice = {
+      config: {
+        key,
+        name: key,
+        description: `Teammate agent: ${key}`,
+        type: AgentType.REACT
+      },
+      client
+    };
+    this.register(key, agentLattice);
+  }
+  /**
+   * Unregister a teammate agent. Call when a team is done to clean up.
+   */
+  unregisterTeammateAgent(key) {
+    return this.remove(key);
+  }
   /**
    * 获取AgentLattice
    * @param key Lattice键名
@@ -6288,6 +9424,8 @@ var getAgentLattice = (key) => agentLatticeManager.getAgentLattice(key);
 var getAgentConfig = (key) => agentLatticeManager.getAgentConfig(key);
 var getAllAgentConfigs = () => agentLatticeManager.getAllAgentConfigs();
 var validateAgentInput = (key, input) => agentLatticeManager.validateAgentInput(key, input);
+var registerTeammateAgent = (key, client) => agentLatticeManager.registerTeammateAgent(key, client);
+var unregisterTeammateAgent = (key) => agentLatticeManager.unregisterTeammateAgent(key);
 var getAgentClient = (key, options) => agentLatticeManager.initializeClient(key, options);
 var createAgentClientFromAgentLattice = (agentLattice, options) => agentLatticeManager.createAgentClientFromConfig(agentLattice, options);
 
@@ -6488,9 +9626,9 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
       next: (chunk) => {
         queue.push(chunk);
         if (resolveNext) {
-          const resolve2 = resolveNext;
+          const resolve3 = resolveNext;
           resolveNext = null;
-          resolve2();
+          resolve3();
         }
       },
       error: (err) => {
@@ -6500,17 +9638,17 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
           errorNext = null;
           reject(err);
         } else if (resolveNext) {
-          const resolve2 = resolveNext;
+          const resolve3 = resolveNext;
           resolveNext = null;
-          resolve2();
+          resolve3();
         }
       },
       complete: () => {
         isCompleted = true;
         if (resolveNext) {
-          const resolve2 = resolveNext;
+          const resolve3 = resolveNext;
           resolveNext = null;
-          resolve2();
+          resolve3();
         }
       }
     });
@@ -6522,8 +9660,8 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
         }
         if (queue.length === 0) {
           if (isCompleted) break;
-          await new Promise((resolve2, reject) => {
-            resolveNext = resolve2;
+          await new Promise((resolve3, reject) => {
+            resolveNext = resolve3;
             errorNext = reject;
           });
         }
@@ -8507,10 +11645,10 @@ var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
     }
     const tools = await this.getAllTools();
     console.log(`[MCP] Registering ${tools.length} tools to Tool Lattice...`);
-    for (const tool36 of tools) {
-      const toolKey = prefix ? `${prefix}_${tool36.name}` : tool36.name;
-      tool36.name = toolKey;
-      toolLatticeManager.registerExistingTool(toolKey, tool36);
+    for (const tool38 of tools) {
+      const toolKey = prefix ? `${prefix}_${tool38.name}` : tool38.name;
+      tool38.name = toolKey;
+      toolLatticeManager.registerExistingTool(toolKey, tool38);
       console.log(`[MCP] Registered tool: ${toolKey}`);
     }
     console.log(`[MCP] Successfully registered ${tools.length} tools to Tool Lattice`);
@@ -8520,6 +11658,70 @@ var mcpManager = McpLatticeManager.getInstance();
 
 // src/index.ts
 import * as Protocols from "@axiom-lattice/protocols";
+
+// src/util/encryption.ts
+import { createCipheriv, createDecipheriv, randomBytes, pbkdf2Sync } from "crypto";
+var ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 16;
+var SALT_LENGTH = 32;
+var ITERATIONS = 1e5;
+var DEFAULT_ENCRYPTION_KEY = "lattice-default-encryption-key-dev-only-32b!";
+var cachedKey = null;
+var keyValidated = false;
+function getEncryptionKey() {
+  if (cachedKey) {
+    return cachedKey;
+  }
+  const key = process.env.LATTICE_ENCRYPTION_KEY || DEFAULT_ENCRYPTION_KEY;
+  cachedKey = pbkdf2Sync(key, "lattice-encryption-salt", ITERATIONS, 32, "sha256");
+  if (!keyValidated) {
+    keyValidated = true;
+    validateEncryptionKey();
+  }
+  return cachedKey;
+}
+function encrypt(plaintext, key) {
+  const actualKey = key || getEncryptionKey();
+  const salt = randomBytes(SALT_LENGTH);
+  const iv = randomBytes(IV_LENGTH);
+  const derivedKey = pbkdf2Sync(actualKey, salt, ITERATIONS, 32, "sha256");
+  const cipher = createCipheriv(ALGORITHM, derivedKey, iv);
+  const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+  const authTag = cipher.getAuthTag();
+  return Buffer.concat([salt, iv, encrypted, authTag]).toString("base64");
+}
+function decrypt(encrypted, key) {
+  const actualKey = key || getEncryptionKey();
+  const data = Buffer.from(encrypted, "base64");
+  const salt = data.subarray(0, SALT_LENGTH);
+  const iv = data.subarray(SALT_LENGTH, SALT_LENGTH + IV_LENGTH);
+  const authTag = data.subarray(-16);
+  const ciphertext = data.subarray(SALT_LENGTH + IV_LENGTH, -16);
+  const derivedKey = pbkdf2Sync(actualKey, salt, ITERATIONS, 32, "sha256");
+  const decipher = createDecipheriv(ALGORITHM, derivedKey, iv);
+  decipher.setAuthTag(authTag);
+  return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf8");
+}
+function isUsingDefaultKey() {
+  return !process.env.LATTICE_ENCRYPTION_KEY;
+}
+function validateEncryptionKey() {
+  if (isUsingDefaultKey()) {
+    if (process.env.NODE_ENV === "production") {
+      console.warn(
+        "\u26A0\uFE0F  WARNING: Using default encryption key in production environment. Set LATTICE_ENCRYPTION_KEY environment variable for security."
+      );
+    } else {
+      console.warn(
+        "\u26A0\uFE0F  WARNING: Using default encryption key. Set LATTICE_ENCRYPTION_KEY environment variable in production."
+      );
+    }
+  }
+}
+function clearEncryptionKeyCache() {
+  cachedKey = null;
+  keyValidated = false;
+}
 export {
   AGENT_TASK_EVENT,
   AgentConfig,
@@ -8528,42 +11730,73 @@ export {
   AgentType,
   ChunkBuffer,
   ChunkBufferLatticeManager,
+  CompositeBackend,
   ConsoleLoggerClient,
   DefaultScheduleClient,
+  EMPTY_CONTENT_WARNING,
   EmbeddingsLatticeManager,
   FileSystemSkillStore,
+  FilesystemBackend,
   GraphBuildOptions,
   InMemoryAssistantStore,
   InMemoryChunkBuffer,
+  InMemoryDatabaseConfigStore,
+  InMemoryMailboxStore,
+  InMemoryTaskListStore,
   InMemoryThreadStore,
+  LINE_NUMBER_WIDTH,
   LoggerLatticeManager,
+  MAX_LINE_LENGTH,
   McpLatticeManager,
+  MemoryBackend,
   MemoryLatticeManager,
   MemoryQueueClient,
   MemoryScheduleStorage,
   MemoryType,
+  MessageType,
   ModelLatticeManager,
   PinoLoggerClient,
   PostgresDatabase,
   Protocols,
   QueueLatticeManager,
+  SandboxFilesystem,
   SandboxLatticeManager,
   ScheduleLatticeManager,
   SkillLatticeManager,
   SqlDatabaseManager,
+  StateBackend,
+  StoreBackend,
   StoreLatticeManager,
+  TOOL_RESULT_TOKEN_LIMIT,
+  TRUNCATION_GUIDANCE,
+  TaskStatus,
+  TeamAgentGraphBuilder,
   ThreadStatus,
   ToolLatticeManager,
   VectorStoreLatticeManager,
   agentLatticeManager,
+  buildGrepResultsDict,
+  checkEmptyContent,
+  clearEncryptionKeyCache,
+  createAgentTeam,
+  createFileData,
   createInfoSqlTool,
   createListTablesSqlTool,
   createQueryCheckerSqlTool,
   createQuerySqlTool,
+  createTeamMiddleware,
+  createTeammateTools,
+  decrypt,
   describeCronExpression,
   embeddingsLatticeManager,
+  encrypt,
   eventBus,
   event_bus_default as eventBusDefault,
+  fileDataToString,
+  formatContentWithLineNumbers,
+  formatGrepMatches,
+  formatGrepResults,
+  formatReadResponse,
   getAgentClient,
   getAgentConfig,
   getAgentLattice,
@@ -8573,6 +11806,7 @@ export {
   getChunkBuffer,
   getEmbeddingsClient,
   getEmbeddingsLattice,
+  getEncryptionKey,
   getLoggerLattice,
   getModelLattice,
   getNextCronTime,
@@ -8585,7 +11819,11 @@ export {
   getToolLattice,
   getVectorStoreClient,
   getVectorStoreLattice,
+  globSearchFiles,
+  grepMatchesFromFiles,
+  grepSearchFiles,
   hasChunkBuffer,
+  isUsingDefaultKey,
   isValidCronExpression,
   isValidSandboxName,
   isValidSkillName,
@@ -8594,6 +11832,7 @@ export {
   modelLatticeManager,
   normalizeSandboxName,
   parseCronExpression,
+  performStringReplacement,
   queueLatticeManager,
   registerAgentLattice,
   registerAgentLattices,
@@ -8606,15 +11845,22 @@ export {
   registerQueueLattice,
   registerScheduleLattice,
   registerStoreLattice,
+  registerTeammateAgent,
   registerToolLattice,
   registerVectorStoreLattice,
   sandboxLatticeManager,
+  sanitizeToolCallId,
   scheduleLatticeManager,
   skillLatticeManager,
   sqlDatabaseManager,
   storeLatticeManager,
   toolLatticeManager,
+  truncateIfTooLong,
+  unregisterTeammateAgent,
+  updateFileData,
   validateAgentInput,
+  validateEncryptionKey,
+  validatePath,
   validateSkillName,
   validateToolInput,
   vectorStoreLatticeManager