@axiom-lattice/core 2.1.100 → 2.1.103

package/dist/index.mjs

@@ -72,6 +72,12 @@ var ModelLattice = class extends BaseChatModel {
   async _generate(messages, options, runManager) {
     return this.llm._generate(messages, options, runManager);
   }
+  /**
+   * Whether the configured model supports vision/image inputs.
+   */
+  get supportsVision() {
+    return this.config.supportsVision || false;
+  }
   /**
    * 将工具绑定到模型
    * @param tools 工具列表
@@ -2636,11 +2642,17 @@ var InMemoryTaskStore = class {
       description: params.description,
       status: params.status || "pending",
       priority: params.priority || "medium",
+      workspaceId: params.workspaceId,
+      projectId: params.projectId,
       dueDate: params.dueDate,
       metadata: params.metadata,
       parentId: params.parentId,
       sourceId: params.sourceId,
       context: params.context,
+      requireReview: params.requireReview ?? false,
+      dependencies: params.dependencies,
+      result: params.result,
+      failureReason: params.failureReason,
       createdAt: now,
       updatedAt: now
     };
@@ -2666,6 +2678,8 @@ var InMemoryTaskStore = class {
     if (filter2.ownerId) results = results.filter((t) => t.ownerId === filter2.ownerId);
     if (filter2.status) results = results.filter((t) => t.status === filter2.status);
     if (filter2.priority) results = results.filter((t) => t.priority === filter2.priority);
+    if (filter2.workspaceId) results = results.filter((t) => t.workspaceId === filter2.workspaceId);
+    if (filter2.projectId) results = results.filter((t) => t.projectId === filter2.projectId);
     if (filter2.parentId) results = results.filter((t) => t.parentId === filter2.parentId);
     if (filter2.sourceId) results = results.filter((t) => t.sourceId === filter2.sourceId);
     if (filter2.metadata) {
@@ -2714,6 +2728,63 @@ var InMemoryTaskStore = class {
   }
 };
 
+// src/store_lattice/InMemoryTaskWorkItemStore.ts
+import { v4 } from "uuid";
+var InMemoryTaskWorkItemStore = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Create a new work item
+   */
+  async create(params) {
+    const id = v4();
+    const item = {
+      id,
+      taskId: params.taskId,
+      tenantId: params.tenantId,
+      workspaceId: params.workspaceId,
+      projectId: params.projectId,
+      action: params.action,
+      actor: params.actor,
+      threadId: params.threadId,
+      summary: params.summary,
+      detail: params.detail,
+      attempt: params.attempt,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    if (!this.store.has(params.tenantId)) {
+      this.store.set(params.tenantId, /* @__PURE__ */ new Map());
+    }
+    const tenantStore = this.store.get(params.tenantId);
+    if (!tenantStore.has(params.taskId)) {
+      tenantStore.set(params.taskId, []);
+    }
+    tenantStore.get(params.taskId).push(item);
+    return item;
+  }
+  /**
+   * List work items matching filter criteria
+   */
+  async list(filter2) {
+    const tenantStore = this.store.get(filter2.tenantId);
+    if (!tenantStore) return [];
+    const items = tenantStore.get(filter2.taskId) || [];
+    let result = [...items];
+    if (filter2.action) {
+      result = result.filter((item) => item.action === filter2.action);
+    }
+    result.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+    if (filter2.offset) {
+      result = result.slice(filter2.offset);
+    }
+    if (filter2.limit) {
+      result = result.slice(0, filter2.limit);
+    }
+    return result;
+  }
+};
+
 // src/store_lattice/InMemoryCollectionStore.ts
 import { v4 as uuidv42 } from "uuid";
 var InMemoryCollectionStore = class {
@@ -2985,6 +3056,12 @@ storeLatticeManager.registerLattice(
   "task",
   defaultTaskStore
 );
+var defaultTaskWorkItemStore = new InMemoryTaskWorkItemStore();
+storeLatticeManager.registerLattice(
+  "default",
+  "taskWorkItem",
+  defaultTaskWorkItemStore
+);
 var defaultCollectionStore = new InMemoryCollectionStore();
 storeLatticeManager.registerLattice(
   "default",
@@ -7063,7 +7140,7 @@ var createBrowserGetInfoTool = ({ vmIsolation }) => {
 };
 
 // src/index.ts
-import { HumanMessage as HumanMessage4 } from "@langchain/core/messages";
+import { HumanMessage as HumanMessage5 } from "@langchain/core/messages";
 
 // src/agent_lattice/types.ts
 import {
@@ -7697,6 +7774,306 @@ var StateBackend = class {
   }
 };
 
+// src/deep_agent_new/backends/imageUtils.ts
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".bmp",
+  ".svg",
+  ".ico",
+  ".tiff",
+  ".tif"
+]);
+var MIME_MAP = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".tiff": "image/tiff",
+  ".tif": "image/tiff"
+};
+function isImageFile(filePath) {
+  const ext = filePath.toLowerCase().slice(filePath.lastIndexOf("."));
+  return IMAGE_EXTENSIONS.has(ext);
+}
+function detectMimeType(filePath) {
+  const ext = filePath.toLowerCase().slice(filePath.lastIndexOf("."));
+  return MIME_MAP[ext] || "application/octet-stream";
+}
+var MAX_IMAGE_SIZE = 50 * 1024 * 1024;
+function validateImageSize(sizeBytes) {
+  if (sizeBytes > MAX_IMAGE_SIZE) {
+    return `Image too large (${(sizeBytes / 1024 / 1024).toFixed(1)}MB). Maximum is 50MB.`;
+  }
+  return null;
+}
+
+// src/deep_agent_new/backends/audioUtils.ts
+var AUDIO_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".webm",
+  ".wav",
+  ".mp3",
+  ".m4a",
+  ".ogg",
+  ".flac",
+  ".aac",
+  ".wma",
+  ".opus",
+  ".amr"
+]);
+function isAudioFile(filePath) {
+  const ext = filePath.toLowerCase().slice(filePath.lastIndexOf("."));
+  return AUDIO_EXTENSIONS.has(ext);
+}
+function detectAudioFormat(filePath) {
+  return filePath.toLowerCase().slice(filePath.lastIndexOf(".") + 1);
+}
+var MAX_AUDIO_SIZE = 25 * 1024 * 1024;
+function validateAudioSize(sizeBytes) {
+  if (sizeBytes > MAX_AUDIO_SIZE) {
+    return `Audio file too large (${(sizeBytes / 1024 / 1024).toFixed(1)}MB). Maximum is 25MB.`;
+  }
+  return null;
+}
+
+// src/deep_agent_new/backends/describeImage.ts
+import { HumanMessage } from "@langchain/core/messages";
+async function describeImage(options) {
+  const { modelKey, mimeType, base64, prompt } = options;
+  const { client } = modelLatticeManager.getModelLattice(modelKey);
+  if (!client.supportsVision) {
+    throw new Error(`Model "${modelKey}" does not support vision.`);
+  }
+  const result = await client.invoke([
+    new HumanMessage({
+      content: [
+        {
+          type: "text",
+          text: prompt || "Please describe this image in detail."
+        },
+        {
+          type: "image_url",
+          image_url: { url: `data:${mimeType};base64,${base64}` }
+        }
+      ]
+    })
+  ]);
+  return result.content || "";
+}
+
+// src/stt_model_lattice/STTModelLattice.ts
+import { OpenAIClient, toFile } from "@langchain/openai";
+var STTModelLattice = class {
+  constructor(key4, config) {
+    this.key = key4;
+    this.config = config;
+    this.client = this;
+    const apiKey = config.apiKey || (config.apiKeyEnvName ? process.env[config.apiKeyEnvName] : void 0) || process.env.OPENAI_API_KEY || "";
+    if (!apiKey) {
+      throw new Error("No API key configured for STT. Set apiKey, apiKeyEnvName, or OPENAI_API_KEY.");
+    }
+    this.openaiClient = new OpenAIClient({
+      apiKey,
+      baseURL: config.baseURL,
+      timeout: config.timeout || 3e4
+    });
+  }
+  /**
+   * Transcribe audio buffer to text.
+   * Routes to whisper or chat API mode based on config.
+   */
+  async transcribe(audio, format) {
+    const mode = this.config.apiMode || "whisper";
+    if (mode === "chat") {
+      return this.transcribeViaChat(audio, format);
+    }
+    return this.transcribeViaWhisper(audio, format);
+  }
+  /**
+   * Transcribe via OpenAI /v1/audio/transcriptions endpoint (multipart).
+   */
+  async transcribeViaWhisper(audio, format) {
+    const mimeType = formatToMimeType(format);
+    const file = typeof File !== "undefined" ? new File([audio], `audio.${format}`, { type: mimeType }) : await toFile(audio, `audio.${format}`, { type: mimeType });
+    const extra = this.config.extra || {};
+    const response = await this.openaiClient.audio.transcriptions.create({
+      file,
+      model: this.config.model || "whisper-1",
+      response_format: "verbose_json",
+      ...extra
+    });
+    const result = response;
+    return {
+      text: result.text,
+      segments: result.segments?.map((s) => ({
+        start: s.start,
+        end: s.end,
+        text: s.text
+      })),
+      confidence: result.segments ? result.segments.reduce((sum, s) => sum + Math.exp(s.avg_logprob ?? -Infinity), 0) / result.segments.length : void 0
+    };
+  }
+  /**
+   * Transcribe via OpenAI /v1/chat/completions with input_audio.
+   * Used by Qwen3-ASR-Flash and similar audio-via-chat models.
+   */
+  async transcribeViaChat(audio, format) {
+    const mimeType = formatToMimeType(format);
+    const dataUri = `data:${mimeType};base64,${audio.toString("base64")}`;
+    const extra = this.config.extra || {};
+    const response = await this.openaiClient.chat.completions.create({
+      model: this.config.model || "qwen3-asr-flash",
+      messages: [
+        {
+          role: "user",
+          content: [
+            {
+              type: "input_audio",
+              input_audio: {
+                data: dataUri,
+                format
+              }
+            }
+          ]
+        }
+      ],
+      ...extra
+    });
+    const result = response;
+    const text = result.choices?.[0]?.message?.content || "";
+    return { text };
+  }
+};
+function formatToMimeType(format) {
+  const mimeTypes = {
+    webm: "audio/webm",
+    wav: "audio/wav",
+    mp3: "audio/mpeg",
+    m4a: "audio/mp4",
+    ogg: "audio/ogg",
+    flac: "audio/flac",
+    aac: "audio/aac"
+  };
+  const lower = format.toLowerCase();
+  if (!mimeTypes[lower]) {
+    console.warn(`Unknown STT audio format "${format}", falling back to audio/webm`);
+  }
+  return mimeTypes[lower] || "audio/webm";
+}
+
+// src/stt_model_lattice/STTModelLatticeManager.ts
+var STTModelLatticeManager = class _STTModelLatticeManager extends BaseLatticeManager {
+  static getInstance() {
+    if (!_STTModelLatticeManager._instance) {
+      _STTModelLatticeManager._instance = new _STTModelLatticeManager();
+    }
+    return _STTModelLatticeManager._instance;
+  }
+  getLatticeType() {
+    return "stt";
+  }
+  /**
+   * Register an STT model lattice.
+   * @param key - Lattice key name
+   * @param config - STT provider configuration
+   */
+  registerLattice(key4, config) {
+    const client = new STTModelLattice(key4, config);
+    const label = config.model || key4;
+    const sttLattice = {
+      key: key4,
+      client,
+      config,
+      label
+    };
+    this.register(key4, sttLattice);
+  }
+  /**
+   * Get an STT model lattice by key.
+   */
+  getSTTModelLattice(key4) {
+    const lattice = this.get(key4);
+    if (!lattice) {
+      throw new Error(`STTModelLattice "${key4}" not found`);
+    }
+    return lattice;
+  }
+  /**
+   * Get STT client instance by key (default tenant).
+   */
+  getSTTClient(key4) {
+    return this.getSTTModelLattice(key4).client;
+  }
+  /**
+   * Get STT client instance by key and tenant.
+   * @param tenantId - Tenant ID for isolation
+   * @param key - Lattice key name
+   */
+  getSTTClientWithTenant(tenantId2, key4) {
+    let lattice = this.getWithTenant(tenantId2, key4);
+    if (!lattice && tenantId2 !== "default") {
+      lattice = this.getWithTenant("default", key4);
+    }
+    if (!lattice) {
+      throw new Error(`STTModelLattice "${key4}" not found for tenant "${tenantId2}"`);
+    }
+    return lattice.client;
+  }
+  /**
+   * Get all registered STT models as info list.
+   */
+  getAllSTTModelInfo() {
+    return this.getAllLattices().map((l) => ({
+      key: l.key,
+      label: l.label,
+      provider: l.config.provider || "openai-compatible",
+      model: l.config.model || "unknown"
+    }));
+  }
+  getAllLattices() {
+    return this.getAll();
+  }
+  hasLattice(key4) {
+    return this.has(key4);
+  }
+  removeLattice(key4) {
+    return this.remove(key4);
+  }
+  clearLattices() {
+    this.clear();
+  }
+  getLatticeCount() {
+    return this.count();
+  }
+  getLatticeKeys() {
+    return this.keys();
+  }
+};
+var sttModelLatticeManager = STTModelLatticeManager.getInstance();
+var registerSTTModelLattice = (key4, config) => sttModelLatticeManager.registerLattice(key4, config);
+var getSTTModelLattice = (key4) => sttModelLatticeManager.getSTTModelLattice(key4);
+var getSTTClient = (key4) => sttModelLatticeManager.getSTTClient(key4);
+var getSTTClientWithTenant = (tenantId2, key4) => sttModelLatticeManager.getSTTClientWithTenant(tenantId2, key4);
+
+// src/deep_agent_new/backends/transcribeAudio.ts
+async function transcribeAudio(options) {
+  const { audioBuffer, format } = options;
+  if (!sttModelLatticeManager.hasLattice("default")) {
+    throw new Error(
+      "No default STT model registered. Use registerSTTModelLattice('default', { ... }) first."
+    );
+  }
+  const client = sttModelLatticeManager.getSTTClient("default");
+  return await client.transcribe(audioBuffer, format);
+}
+
 // src/deep_agent_new/middleware/fs.ts
 var FileDataSchema = z310.object({
   content: z310.array(z310.string()),
@@ -7755,7 +8132,7 @@ Path conventions:
 - glob: find files matching a pattern (e.g., "/project/**/*.py")
 - grep: search for text within files`;
 var LS_TOOL_DESCRIPTION = "List files and directories in a directory";
-var READ_FILE_TOOL_DESCRIPTION = "Read the contents of a file";
+var READ_FILE_TOOL_DESCRIPTION = "Read the contents of a file. For image files (png, jpg, gif, webp, bmp, svg), returns a visual description when the current model supports vision; otherwise returns an error suggesting a vision-capable model. For audio files (webm, wav, mp3, m4a, ogg, flac, aac, wma, opus, amr), transcribes the content using the default STT model; if none is registered, returns an error with registration instructions.";
 var WRITE_FILE_TOOL_DESCRIPTION = "Write content to a new file. Returns an error if the file already exists";
 var EDIT_FILE_TOOL_DESCRIPTION = "Edit a file by replacing a specific string with a new string";
 var GLOB_TOOL_DESCRIPTION = "Find files matching a glob pattern (e.g., '**/*.py' for all Python files)";
@@ -7808,6 +8185,66 @@ function createReadFileTool(backend, options) {
       };
       const resolvedBackend = await getBackend(backend, stateAndStore);
       const { file_path, offset = 0, limit = 2e3 } = input;
+      if (isImageFile(file_path)) {
+        const modelKey = runConfig?.modelConfig?.modelKey || "default";
+        const { client } = modelLatticeManager.getModelLattice(modelKey);
+        if (!client.supportsVision) {
+          return `[\u56FE\u7247] ${file_path}
+\u5F53\u524D\u6A21\u578B "${modelKey}" \u4E0D\u652F\u6301\u89C6\u89C9\u80FD\u529B\uFF0C\u65E0\u6CD5\u8BFB\u53D6\u56FE\u7247\u5185\u5BB9\u3002\u8BF7\u5207\u6362\u5230\u652F\u6301\u591A\u6A21\u6001\u7684\u6A21\u578B\uFF08\u5982 GPT-4o\uFF09\u3002`;
+        }
+        if (!resolvedBackend.readBinary) {
+          return `[\u56FE\u7247] ${file_path}
+\u5F53\u524D\u540E\u7AEF\u4E0D\u652F\u6301\u4E8C\u8FDB\u5236\u8BFB\u53D6\uFF0C\u65E0\u6CD5\u5904\u7406\u56FE\u7247\u3002`;
+        }
+        try {
+          const buffer2 = await resolvedBackend.readBinary(file_path);
+          const sizeWarning = validateImageSize(buffer2.length);
+          if (sizeWarning) {
+            return `[\u56FE\u7247] ${file_path}
+${sizeWarning}`;
+          }
+          const mimeType = detectMimeType(file_path);
+          const description = await describeImage({
+            modelKey,
+            mimeType,
+            base64: buffer2.toString("base64")
+          });
+          return `[\u56FE\u7247] ${file_path}\uFF08${mimeType}\uFF0C${(buffer2.length / 1024).toFixed(1)}KB\uFF09
+
+${description}`;
+        } catch (error) {
+          return `[\u56FE\u7247] ${file_path}
+\u8BFB\u53D6\u56FE\u7247\u5931\u8D25\uFF1A${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`;
+        }
+      }
+      if (isAudioFile(file_path)) {
+        if (!resolvedBackend.readBinary) {
+          return `[Audio] ${file_path}
+The current backend does not support binary reading, unable to process audio.`;
+        }
+        try {
+          const buffer2 = await resolvedBackend.readBinary(file_path);
+          const sizeWarning = validateAudioSize(buffer2.length);
+          if (sizeWarning) {
+            return `[Audio] ${file_path}
+${sizeWarning}`;
+          }
+          const format = detectAudioFormat(file_path);
+          const result = await transcribeAudio({ audioBuffer: buffer2, format });
+          let output = `[Audio] ${file_path} (${format}, ${(buffer2.length / 1024).toFixed(1)}KB)`;
+          if (result.confidence !== void 0) {
+            output += `
+Confidence: ${(result.confidence * 100).toFixed(1)}%`;
+          }
+          output += `
+
+${result.text}`;
+          return output;
+        } catch (error) {
+          return `[Audio] ${file_path}
+Audio transcription failed: ${error instanceof Error ? error.message : "Unknown error"}`;
+        }
+      }
       return await resolvedBackend.read(file_path, offset, limit);
     },
     {
@@ -9401,19 +9838,13 @@ var SandboxFilesystem = class {
       throw new Error(`Error reading file '${filePath}': ${e.message}`);
     }
   }
+  async readBinary(filePath) {
+    return this.sandbox.file.downloadFile({ file: filePath });
+  }
   async write(filePath, content) {
     try {
       await this.sandbox.file.writeFile(filePath, content);
-      return {
-        path: filePath,
-        filesUpdate: {
-          [filePath]: {
-            content: content.split("\n"),
-            created_at: (/* @__PURE__ */ new Date()).toISOString(),
-            modified_at: (/* @__PURE__ */ new Date()).toISOString()
-          }
-        }
-      };
+      return { path: filePath, filesUpdate: null };
     } catch (e) {
       throw new Error(`Error writing file '${filePath}': ${e.message}`);
     }
@@ -9427,10 +9858,7 @@ var SandboxFilesystem = class {
         new_str: newString,
         replace_mode: replaceAll ? "ALL" : "FIRST"
       });
-      return {
-        path: filePath,
-        filesUpdate: null
-      };
+      return { path: filePath, filesUpdate: null };
     } catch (e) {
       throw new Error(`Error editing file '${filePath}': ${e.message}`);
     }
@@ -9535,16 +9963,16 @@ import {
 } from "langchain";
 
 // src/deep_agent_new/middleware/subagents.ts
-import { z as z42 } from "zod/v3";
+import { z as z43 } from "zod/v3";
 import {
-  createMiddleware as createMiddleware9,
+  createMiddleware as createMiddleware10,
   createAgent as createAgent2,
-  tool as tool39,
+  tool as tool40,
   ToolMessage as ToolMessage3,
   humanInTheLoopMiddleware
 } from "langchain";
 import { Command as Command3, getCurrentTaskInput as getCurrentTaskInput2, GraphInterrupt as GraphInterrupt2 } from "@langchain/langgraph";
-import { HumanMessage as HumanMessage2 } from "@langchain/core/messages";
+import { HumanMessage as HumanMessage3 } from "@langchain/core/messages";
 
 // src/agent_worker/agent_worker_graph.ts
 import {
@@ -9960,7 +10388,7 @@ var QueueMode = /* @__PURE__ */ ((QueueMode2) => {
 
 // src/services/Agent.ts
 import { Command as Command2 } from "@langchain/langgraph";
-import { HumanMessage, filterMessages } from "langchain";
+import { HumanMessage as HumanMessage2, filterMessages } from "langchain";
 
 // src/chunk_buffer_lattice/ChunkBuffer.ts
 var ChunkBuffer = class {
@@ -10277,7 +10705,7 @@ var buffer = new InMemoryChunkBuffer({
 registerChunkBuffer("default", buffer);
 
 // src/services/Agent.ts
-import { v4 } from "uuid";
+import { v4 as v42 } from "uuid";
 var ThreadStatus2 = /* @__PURE__ */ ((ThreadStatus3) => {
   ThreadStatus3["IDLE"] = "idle";
   ThreadStatus3["BUSY"] = "busy";
@@ -10323,7 +10751,7 @@ var Agent = class {
               runConfig
             },
             configurable: {
-              run_id: v4(),
+              run_id: v42(),
               ...runConfig,
               runConfig
             },
@@ -10396,7 +10824,7 @@ var Agent = class {
               runConfig
             },
             configurable: {
-              run_id: v4(),
+              run_id: v42(),
               ...runConfig,
               runConfig
               // Inject runConfig for tools to access
@@ -10460,7 +10888,7 @@ var Agent = class {
             });
             const humanContent = p.content;
             const input = {
-              messages: [new HumanMessage({ id: humanContent.id, content: humanContent.message })]
+              messages: [new HumanMessage2({ id: humanContent.id, content: humanContent.message })]
             };
             if (files) {
               input.files = files;
@@ -10534,7 +10962,7 @@ var Agent = class {
             remainingPendings.forEach((p) => {
               this.queueStore?.markProcessing(p.id);
               const humanContent = p.content;
-              userMessages.push(new HumanMessage({ id: humanContent.id, content: humanContent.message }));
+              userMessages.push(new HumanMessage2({ id: humanContent.id, content: humanContent.message }));
               this.publish("message:started", {
                 type: "message:started",
                 messageId: humanContent.id,
@@ -10614,7 +11042,7 @@ var Agent = class {
               if (signal?.aborted) break;
               await this.queueStore?.markProcessing(p.id);
               const humanContent = p.content;
-              const message = new HumanMessage({ id: humanContent.id, content: humanContent.message });
+              const message = new HumanMessage2({ id: humanContent.id, content: humanContent.message });
               const startTime = Date.now();
               this.publish("message:started", {
                 type: "message:started",
@@ -10782,10 +11210,10 @@ var Agent = class {
     };
   }
   async invoke(queueMessage, signal) {
-    const messageId = v4();
+    const messageId = v42();
     const input = {
       ...queueMessage.input,
-      messages: [new HumanMessage({ id: messageId, content: queueMessage.input.message })]
+      messages: [new HumanMessage2({ id: messageId, content: queueMessage.input.message })]
     };
     const inputMessage = { ...queueMessage, input };
     return this.agentExecutor(inputMessage, signal);
@@ -10801,10 +11229,10 @@ var Agent = class {
    * to avoid exposing internal annotation data.
    */
   async invokeWithState(queueMessage, signal) {
-    const messageId = v4();
+    const messageId = v42();
     const input = {
       ...queueMessage.input,
-      messages: [new HumanMessage({ id: messageId, content: queueMessage.input.message })]
+      messages: [new HumanMessage2({ id: messageId, content: queueMessage.input.message })]
     };
     const inputMessage = { ...queueMessage, input };
     const { runnable_agent, runConfig } = await this.getLatticeClientAndRuntimeConfig(inputMessage.custom_run_config);
@@ -10817,7 +11245,7 @@ var Agent = class {
       {
         context: { runConfig },
         configurable: {
-          run_id: v4(),
+          run_id: v42(),
           ...runConfig,
           runConfig
         },
@@ -10993,7 +11421,7 @@ var Agent = class {
    */
   async addMessage(queueMessage, mode) {
     const useMode = mode ?? this.queueMode.mode;
-    const messageId = queueMessage.input.id || v4();
+    const messageId = queueMessage.input.id || v42();
     const messages = queueMessage.input.messages;
     const legacyMessage = queueMessage.input.message;
     if (!messages && !legacyMessage) {
@@ -11485,86 +11913,428 @@ var AgentInstanceManager = class _AgentInstanceManager {
 };
 var agentInstanceManager = AgentInstanceManager.getInstance();
 
-// src/deep_agent_new/middleware/subagents.ts
-var DEFAULT_SUBAGENT_PROMPT = "In order to complete the objective that the user asks of you, you have access to a number of standard tools.";
-var EXCLUDED_STATE_KEYS = ["messages", "todos", "jumpTo"];
-var DEFAULT_GENERAL_PURPOSE_DESCRIPTION = "General-purpose agent for researching complex questions, searching for files and content, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. This agent has access to all tools as the main agent.";
-function getTaskToolDescription(subagentDescriptions) {
-  return subagentDescriptions.length > 0 ? `
-Launch an ephemeral subagent to handle complex, multi-step independent tasks with isolated context windows.
-
-Available agent types and the tools they have access to:
-${subagentDescriptions.join("\n")}
-
-When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.
-
-## Usage notes:
-1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
-2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
-3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
-4. The agent's outputs should generally be trusted
-5. Clearly tell the agent whether you expect it to create content, perform analysis, or just do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent
-6. If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
-7. When only the general-purpose agent is provided, you should use it for all tasks. It is great for isolating context and token usage, and completing specific, complex tasks, as it has all the same capabilities as the main agent.
-
-### Example usage of the general-purpose agent:
-
-<example_agent_descriptions>
-"general-purpose": use this agent for general purpose tasks, it has access to all tools as the main agent.
-</example_agent_descriptions>
-
-<example>
-User: "I want to conduct research on the accomplishments of Lebron James, Michael Jordan, and Kobe Bryant, and then compare them."
-Assistant: *Uses the task tool in parallel to conduct isolated research on each of the three players*
-Assistant: *Synthesizes the results of the three isolated research tasks and responds to the User*
-<commentary>
-Research is a complex, multi-step task in it of itself.
-The research of each individual player is not dependent on the research of the other players.
-The assistant uses the task tool to break down the complex objective into three isolated tasks.
-Each research task only needs to worry about context and tokens about one player, then returns synthesized information about each player as the Tool Result.
-This means each research task can dive deep and spend tokens and context deeply researching each player, but the final result is synthesized information, and saves us tokens in the long run when comparing the players to each other.
-</commentary>
-</example>
-
-<example>
-User: "Analyze a single large code repository for security vulnerabilities and generate a report."
-Assistant: *Launches a single \`task\` subagent for the repository analysis*
-Assistant: *Receives report and integrates results into final summary*
-<commentary>
-Subagent is used to isolate a large, context-heavy task, even though there is only one. This prevents the main thread from being overloaded with details.
-If the user then asks followup questions, we have a concise report to reference instead of the entire history of analysis and tool calls, which is good and saves us time and money.
-</commentary>
-</example>
-
-<example>
-User: "Schedule two meetings for me and prepare agendas for each."
-Assistant: *Calls the task tool in parallel to launch two \`task\` subagents (one per meeting) to prepare agendas*
-Assistant: *Returns final schedules and agendas*
-<commentary>
-Tasks are simple individually, but subagents help silo agenda preparation.
-Each subagent only needs to worry about the agenda for one meeting.
-</commentary>
-</example>
-
-<example>
-User: "I want to order a pizza from Dominos, order a burger from McDonald's, and order a salad from Subway."
-Assistant: *Calls tools directly in parallel to order a pizza from Dominos, a burger from McDonald's, and a salad from Subway*
-<commentary>
-The assistant did not use the task tool because the objective is super simple and clear and only requires a few trivial tool calls.
-It is better to just complete the task directly and NOT use the \`task\`tool.
-</commentary>
-</example>
-
-### Example usage with custom agents:
-
-<example_agent_descriptions>
-"content-reviewer": use this agent after you are done creating significant content or documents
-"greeting-responder": use this agent when to respond to user greetings with a friendly joke
-"research-analyst": use this agent to conduct thorough research on complex topics
-</example_agent_description>
-
-<example>
-user: "Please write a function that checks if a number is prime"
+// src/middlewares/taskMiddleware.ts
+import { createMiddleware as createMiddleware9, tool as tool39 } from "langchain";
+import { z as z42 } from "zod";
+function getRunConfig(config) {
+  const c = config;
+  return c?.configurable?.runConfig ?? {};
+}
+function getTaskStore() {
+  return getStoreLattice("default", "task").store;
+}
+var VALID_TRANSITIONS = {
+  pending: ["in_progress", "cancelled"],
+  in_progress: ["completed", "review", "failed", "interrupted", "cancelled"],
+  review: ["completed", "in_progress", "cancelled"],
+  failed: ["in_progress", "cancelled"],
+  interrupted: ["in_progress", "cancelled"],
+  completed: [],
+  cancelled: []
+};
+function isValidTransition(from, to) {
+  const allowed = VALID_TRANSITIONS[from];
+  if (!allowed) return false;
+  return allowed.includes(to);
+}
+function getTaskWorkItemStore() {
+  return getStoreLattice("default", "taskWorkItem").store;
+}
+var manageTaskSchema = z42.object({
+  action: z42.enum(["create", "list", "update", "delete"]).describe("Action to perform. Available: create, list, update, delete. To mark a task complete, use update with status='completed'"),
+  id: z42.string().optional().describe("Task ID (required for update and delete)"),
+  title: z42.string().optional().describe("Task title (required for create)"),
+  description: z42.string().optional().describe("Task description in Markdown"),
+  priority: z42.enum(["low", "medium", "high"]).optional().describe("Priority level"),
+  status: z42.enum(["pending", "in_progress", "review", "failed", "interrupted", "completed", "cancelled"]).optional().describe("Task status"),
+  dueDate: z42.string().optional().describe("Due date (ISO 8601 format)"),
+  metadata: z42.record(z42.unknown()).optional().describe("Structured metadata (e.g. projectId, module)"),
+  parentId: z42.string().optional().describe("Parent task ID for grouping subtasks"),
+  sourceId: z42.string().optional().describe("Source session/thread ID"),
+  context: z42.record(z42.unknown()).optional().describe("Additional context data"),
+  ownerType: z42.enum(["user", "agent"]).optional().describe("Owner type. Defaults to 'user' if omitted"),
+  ownerId: z42.string().optional().describe("Owner ID. Auto-filled from current user/agent if omitted"),
+  requireReview: z42.boolean().optional().describe("If true, completing sends task to 'review' status instead of 'completed'"),
+  dependencies: z42.array(z42.string()).optional().describe("List of task IDs that must be completed before this task can start"),
+  result: z42.string().optional().describe("Result summary when task is completed"),
+  failureReason: z42.string().optional().describe("Reason for failure (use when status='failed')"),
+  summary: z42.string().optional().describe("Brief summary of the operation")
+});
+function createTaskMiddleware() {
+  const handleManageTask = async (input, config) => {
+    const rc = getRunConfig(config);
+    const tenantId2 = rc.tenantId || "default";
+    const workspaceId = rc.workspaceId;
+    const projectId = rc.projectId;
+    const ownerId = input.ownerId || (input.ownerType === "agent" ? rc.assistant_id : null) || rc.user_id;
+    const store = getTaskStore();
+    switch (input.action) {
+      case "create": {
+        if (!input.title) {
+          return JSON.stringify({
+            success: false,
+            error: "title is required for create action",
+            hint: "Provide a short, descriptive title for the task"
+          });
+        }
+        const task = await store.create({
+          tenantId: tenantId2,
+          ownerType: input.ownerType || "user",
+          ownerId,
+          title: input.title,
+          description: input.description,
+          priority: input.priority || "medium",
+          status: input.status || "pending",
+          dueDate: input.dueDate,
+          metadata: input.metadata,
+          parentId: input.parentId,
+          sourceId: input.sourceId,
+          context: input.context,
+          requireReview: input.requireReview,
+          dependencies: input.dependencies,
+          workspaceId,
+          projectId
+        });
+        return JSON.stringify({ success: true, data: task });
+      }
+      case "list": {
+        const filter2 = {
+          tenantId: tenantId2,
+          ownerType: input.ownerType,
+          ownerId: input.ownerId,
+          status: input.status,
+          priority: input.priority,
+          projectId
+        };
+        const tasks = await store.list(filter2);
+        return JSON.stringify({ success: true, data: tasks, count: tasks.length });
+      }
+      case "update": {
+        if (!input.id) {
+          return JSON.stringify({
+            success: false,
+            error: "id is required for update action",
+            hint: "Pass the task ID you want to update"
+          });
+        }
+        const existing = await store.getById(tenantId2, input.id);
+        if (!existing) {
+          return JSON.stringify({
+            success: false,
+            error: `Task '${input.id}' not found`,
+            hint: "Use list to see available tasks and their IDs"
+          });
+        }
+        if (input.status) {
+          if (!isValidTransition(existing.status, input.status)) {
+            const allowed = VALID_TRANSITIONS[existing.status] || [];
+            return JSON.stringify({
+              success: false,
+              error: `Cannot transition task from '${existing.status}' to '${input.status}'`,
+              allowedTransitions: allowed,
+              hint: `From '${existing.status}', valid transitions are: ${allowed.join(", ")}`
+            });
+          }
+        }
+        if (input.status === "in_progress" && existing.dependencies && existing.dependencies.length > 0) {
+          const incompleteDeps = [];
+          for (const depId of existing.dependencies) {
+            const depTask = await store.getById(tenantId2, depId);
+            if (!depTask || depTask.status !== "completed") {
+              incompleteDeps.push(depId);
+            }
+          }
+          if (incompleteDeps.length > 0) {
+            return JSON.stringify({
+              success: false,
+              error: `Cannot start task '${input.id}': ${incompleteDeps.length} dependencies not completed`,
+              blockedBy: incompleteDeps,
+              hint: `These tasks must be completed first: ${incompleteDeps.join(", ")}`
+            });
+          }
+        }
+        let effectiveStatus = input.status;
+        if (existing.requireReview && input.status === "completed" && existing.status === "in_progress") {
+          effectiveStatus = "review";
+        }
+        const updates = {};
+        const settableFields = [
+          "title",
+          "description",
+          "priority",
+          "dueDate",
+          "metadata",
+          "parentId",
+          "sourceId",
+          "context",
+          "ownerType",
+          "ownerId",
+          "result",
+          "failureReason",
+          "requireReview",
+          "dependencies"
+        ];
+        for (const field of settableFields) {
+          if (input[field] !== void 0) {
+            updates[field] = input[field];
+          }
+        }
+        if (effectiveStatus !== void 0) {
+          updates.status = effectiveStatus;
+        }
+        const updated = await store.update(tenantId2, input.id, updates);
+        if (!updated) {
+          return JSON.stringify({
+            success: false,
+            error: `Failed to update task '${input.id}'`,
+            hint: "The task may have been deleted or the ID is incorrect"
+          });
+        }
+        const actionMap = {
+          pending: "pending",
+          in_progress: "started",
+          review: "submitted",
+          failed: "failed",
+          interrupted: "interrupted",
+          completed: "completed",
+          cancelled: "cancelled"
+        };
+        const workItemAction = effectiveStatus ? actionMap[effectiveStatus] || "updated" : "updated";
+        const workItemSummary = input.summary || (effectiveStatus ? `Status changed to ${effectiveStatus}` : void 0);
+        const workItemStore = getTaskWorkItemStore();
+        await workItemStore.create({
+          taskId: input.id,
+          tenantId: tenantId2,
+          action: workItemAction,
+          actor: input.ownerType === "agent" ? `agent:${ownerId}` : `user:${ownerId}`,
+          threadId: input.sourceId,
+          summary: workItemSummary,
+          detail: {
+            ...input.result !== void 0 && { result: input.result },
+            ...input.failureReason !== void 0 && { failureReason: input.failureReason }
+          },
+          workspaceId,
+          projectId
+        });
+        return JSON.stringify({ success: true, data: updated });
+      }
+      case "delete": {
+        if (!input.id) {
+          return JSON.stringify({
+            success: false,
+            error: "id is required for delete action",
+            hint: "Pass the task ID you want to delete"
+          });
+        }
+        const deleted = await store.delete(tenantId2, input.id);
+        if (!deleted) {
+          return JSON.stringify({
+            success: false,
+            error: `Task '${input.id}' not found or could not be deleted`,
+            hint: "Use list to verify the task exists"
+          });
+        }
+        return JSON.stringify({ success: true, message: `Task '${input.id}' deleted` });
+      }
+      default:
+        return JSON.stringify({
+          success: false,
+          error: `Unknown action '${input.action}'`,
+          availableActions: ["create", "list", "update", "delete"],
+          hint: "To mark a task complete, use action='update' with status='completed'"
+        });
+    }
+  };
+  return createMiddleware9({
+    name: "TaskMiddleware",
+    contextSchema,
+    wrapModelCall: async (request, handler) => {
+      const taskPrompt = `## Task Management
+
+You can use the \`manage_task\` tool to create persistent tasks for user-visible work tracking.
+
+### When to create a task
+- The user explicitly asks you to track, manage, or follow up on work
+- The work spans multiple sessions or might need resumption later
+- The user needs to review or approve output before it is considered done
+- There are multiple independent work items the user wants visibility into
+
+### When NOT to create a task
+- One-shot lookups or simple Q&A ("what is X?", "search for Y")
+- Internal exploration steps you take to understand the problem (use \`write_todos\` for your execution plan instead)
+- Trivial single-step actions that complete in the same turn
+- Conversational or informational requests with no deliverable
+
+### Ownership defaults
+- No params: ownerType defaults to "user" with current user's ID
+- ownerType="agent": auto-fills ownerId from current agent (subtask for yourself)
+- Explicit ownerId: assign to a specific agent or user`;
+      return handler({
+        ...request,
+        systemPrompt: taskPrompt + "\n\n" + (request.systemPrompt ?? "")
+      });
+    },
+    tools: [
+      tool39(
+        handleManageTask,
+        {
+          name: "manage_task",
+          description: `Manage persistent tasks. CRUD operations for user and agent tasks.
+
+## Owner defaults
+- No ownerType/ownerId: auto-assigned to current user
+- ownerType="agent" without ownerId: auto-assigned to current agent
+- Explicit ownerId: assign to a specific agent (cross-agent delegation)
+
+## Actions
+- create: Create a task (title required; priority/description/dueDate/metadata/parentId/context optional)
+- list: List tasks, filterable by ownerType/status/priority
+- update: Update a task (id required; pass only the fields to change)
+  To mark complete: update with status='completed'
+  To mark failed: update with status='failed', failureReason='...'
+  Status transitions are validated \u2014 only allowed transitions will succeed.
+- delete: Delete a task (id required)`,
+          schema: manageTaskSchema
+        }
+      )
+    ]
+  });
+}
+var taskPlugin = {
+  meta: {
+    type: "task",
+    name: "Task Management",
+    description: "Enables persistent task management with delegation and tracking",
+    configSchema: {
+      type: "object",
+      title: "Task Management Configuration",
+      description: "Zero-configuration task management",
+      properties: {}
+    },
+    defaultConfig: {}
+  },
+  middleware: () => createTaskMiddleware(),
+  skills: {
+    "task-definition": `## Using manage_task
+
+### Task description format
+
+When creating a task with manage_task, write the description in this Markdown structure:
+
+## Objective
+[One sentence \u2014 what result to achieve, as measurable as possible]
+
+## Acceptance Criteria
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+## Deliverables
+- Deliverable description
+
+Update the checklist as you work: change \`[ ]\` to \`[x]\` when a criterion is met.
+
+### Subtasks (parentId)
+
+Use \`parentId\` to group related tasks under a parent. Create the parent task first, then create each subtask with \`parentId\` pointing to the parent.
+
+### Dependencies
+
+Use the \`dependencies\` field to declare prerequisites. A task cannot be started (\`in_progress\`) until all its dependencies are \`completed\`. The validation happens automatically \u2014 no manual checking needed.
+
+### requireReview
+
+Set \`requireReview: true\` if the user should approve output before the task is considered done. When enabled, completing the task sends it to \`review\` status instead of \`completed\`.
+
+### Reporting results
+
+When a task is finished:
+- \`update(status: "completed", result: "summary of what was done")\`
+- If unable to complete: \`update(status: "failed", failureReason: "specific reason")\`
+- If blocked waiting for user input: \`update(status: "interrupted", summary: "what you need")\`
+- Use description updates to append progress notes between status changes.`
+  }
+};
+
+// src/deep_agent_new/middleware/subagents.ts
+var DEFAULT_SUBAGENT_PROMPT = "In order to complete the objective that the user asks of you, you have access to a number of standard tools.";
+var EXCLUDED_STATE_KEYS = ["messages", "todos", "jumpTo"];
+var DEFAULT_GENERAL_PURPOSE_DESCRIPTION = "General-purpose agent for researching complex questions, searching for files and content, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. This agent has access to all tools as the main agent.";
+function getTaskToolDescription(subagentDescriptions) {
+  return subagentDescriptions.length > 0 ? `
+Launch an ephemeral subagent to handle complex, multi-step independent tasks with isolated context windows.
+
+Available agent types and the tools they have access to:
+${subagentDescriptions.join("\n")}
+
+When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.
+
+## Usage notes:
+1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
+2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
+3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
+4. The agent's outputs should generally be trusted
+5. Clearly tell the agent whether you expect it to create content, perform analysis, or just do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent
+6. If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
+7. When only the general-purpose agent is provided, you should use it for all tasks. It is great for isolating context and token usage, and completing specific, complex tasks, as it has all the same capabilities as the main agent.
+
+### Example usage of the general-purpose agent:
+
+<example_agent_descriptions>
+"general-purpose": use this agent for general purpose tasks, it has access to all tools as the main agent.
+</example_agent_descriptions>
+
+<example>
+User: "I want to conduct research on the accomplishments of Lebron James, Michael Jordan, and Kobe Bryant, and then compare them."
+Assistant: *Uses the task tool in parallel to conduct isolated research on each of the three players*
+Assistant: *Synthesizes the results of the three isolated research tasks and responds to the User*
+<commentary>
+Research is a complex, multi-step task in it of itself.
+The research of each individual player is not dependent on the research of the other players.
+The assistant uses the task tool to break down the complex objective into three isolated tasks.
+Each research task only needs to worry about context and tokens about one player, then returns synthesized information about each player as the Tool Result.
+This means each research task can dive deep and spend tokens and context deeply researching each player, but the final result is synthesized information, and saves us tokens in the long run when comparing the players to each other.
+</commentary>
+</example>
+
+<example>
+User: "Analyze a single large code repository for security vulnerabilities and generate a report."
+Assistant: *Launches a single \`task\` subagent for the repository analysis*
+Assistant: *Receives report and integrates results into final summary*
+<commentary>
+Subagent is used to isolate a large, context-heavy task, even though there is only one. This prevents the main thread from being overloaded with details.
+If the user then asks followup questions, we have a concise report to reference instead of the entire history of analysis and tool calls, which is good and saves us time and money.
+</commentary>
+</example>
+
+<example>
+User: "Schedule two meetings for me and prepare agendas for each."
+Assistant: *Calls the task tool in parallel to launch two \`task\` subagents (one per meeting) to prepare agendas*
+Assistant: *Returns final schedules and agendas*
+<commentary>
+Tasks are simple individually, but subagents help silo agenda preparation.
+Each subagent only needs to worry about the agenda for one meeting.
+</commentary>
+</example>
+
+<example>
+User: "I want to order a pizza from Dominos, order a burger from McDonald's, and order a salad from Subway."
+Assistant: *Calls tools directly in parallel to order a pizza from Dominos, a burger from McDonald's, and a salad from Subway*
+<commentary>
+The assistant did not use the task tool because the objective is super simple and clear and only requires a few trivial tool calls.
+It is better to just complete the task directly and NOT use the \`task\`tool.
+</commentary>
+</example>
+
+### Example usage with custom agents:
+
+<example_agent_descriptions>
+"content-reviewer": use this agent after you are done creating significant content or documents
+"greeting-responder": use this agent when to respond to user greetings with a friendly joke
+"research-analyst": use this agent to conduct thorough research on complex topics
+</example_agent_description>
+
+<example>
+user: "Please write a function that checks if a number is prime"
 assistant: Sure let me write a function that checks if a number is prime
 assistant: First let me use the Write tool to write a function that checks if a number is prime
 assistant: I'm going to use the Write tool to write the following code:
@@ -11667,8 +12437,12 @@ function getSubagents(options) {
   const defaultSubagentMiddleware = defaultMiddleware || [];
   const agents = {};
   const subagentDescriptions = [];
+  const hasTaskMiddleware = defaultSubagentMiddleware.some(
+    (m) => m?.name === "TaskMiddleware"
+  );
+  const taskMiddleware = hasTaskMiddleware ? [] : [createTaskMiddleware()];
   if (generalPurposeAgent) {
-    const generalPurposeMiddleware = [...defaultSubagentMiddleware];
+    const generalPurposeMiddleware = [...defaultSubagentMiddleware, ...taskMiddleware];
     if (defaultInterruptOn) {
       generalPurposeMiddleware.push(
         humanInTheLoopMiddleware({ interruptOn: defaultInterruptOn })
@@ -11694,7 +12468,7 @@ function getSubagents(options) {
     if ("runnable" in agentParams) {
       agents[agentParams.key] = agentParams.runnable;
     } else {
-      const middleware = agentParams.middleware ? [...defaultSubagentMiddleware, ...agentParams.middleware] : [...defaultSubagentMiddleware];
+      const middleware = agentParams.middleware ? [...defaultSubagentMiddleware, ...taskMiddleware, ...agentParams.middleware] : [...defaultSubagentMiddleware, ...taskMiddleware];
       const interruptOn = agentParams.interruptOn || defaultInterruptOn;
       if (interruptOn)
         middleware.push(humanInTheLoopMiddleware({ interruptOn }));
@@ -11748,7 +12522,7 @@ function createTaskTool(options) {
     generalPurposeAgent
   });
   const finalTaskDescription = taskDescription ? taskDescription : getTaskToolDescription(subagentDescriptions);
-  return tool39(
+  return tool40(
     async (input, config) => {
       const { description, subagent_type, async } = input;
       let assistant_id = subagent_type;
@@ -11778,7 +12552,17 @@ function createTaskTool(options) {
         }
         const currentState = getCurrentTaskInput2();
         const subagentState = filterStateForSubagent(currentState);
-        subagentState.messages = [new HumanMessage2({ content: description })];
+        subagentState.messages = input.taskId ? [
+          new HumanMessage3({
+            content: `${description}
+
+---
+You are executing a persistent task (ID: ${input.taskId}). Use manage_task.update to report your progress:
+- Set status to 'in_progress' when you start working
+- Set status to 'completed' when done (or 'review' if requireReview is true, or 'failed' if you cannot complete, or 'interrupted' if you need more information)
+- You can also update the description to append progress notes or update the acceptance criteria checklist.`
+          })
+        ] : [new HumanMessage3({ content: description })];
         const subagent_thread_id = config.configurable?.thread_id + "____" + assistant_id + "_" + config.toolCall.id;
         if (async) {
           const tenantId2 = config.configurable?.runConfig?.tenantId;
@@ -11810,11 +12594,12 @@ function createTaskTool(options) {
             runConfig: {
               ...config.configurable?.runConfig,
               assistant_id,
-              thread_id: subagent_thread_id
+              thread_id: subagent_thread_id,
+              taskId: input.taskId
             },
-            main_thread_id: mainThreadId,
             main_tenant_id: tenantId2,
-            main_assistant_id: mainAssistantId
+            main_assistant_id: mainAssistantId,
+            main_thread_id: mainThreadId
           }, false).catch((err) => {
             console.error(`Failed to start async subagent ${subagent_thread_id}:`, err);
           });
@@ -11842,7 +12627,8 @@ The result will be delivered as a notification when complete. Do not poll.`,
           runConfig: {
             ...config.configurable?.runConfig,
             assistant_id,
-            thread_id: subagent_thread_id
+            thread_id: subagent_thread_id,
+            taskId: input.taskId
           }
         });
         const result = workerResult.finalState?.values;
@@ -11870,18 +12656,21 @@ The result will be delivered as a notification when complete. Do not poll.`,
     {
       name: "task",
       description: finalTaskDescription,
-      schema: z42.object({
-        description: z42.string().describe("The task to execute with the selected agent"),
-        subagent_type: z42.string().describe(
+      schema: z43.object({
+        description: z43.string().describe("The task to execute with the selected agent"),
+        subagent_type: z43.string().describe(
           `Name of the agent to use. Available: ${Object.keys(
             subagentGraphs
           ).join(", ")}`
         ),
         ...allowAsync ? {
-          async: z42.boolean().default(false).describe(
+          async: z43.boolean().default(false).describe(
             "When true, runs the task in the background and returns immediately. Use for independent tasks that can run in parallel. The result is delivered as a notification when complete. Use check_async_task or list_async_tasks to monitor progress."
           )
-        } : {}
+        } : {},
+        taskId: z43.string().optional().describe(
+          "Optional: ID of a TaskItem created via manage_task. When set, the subagent will update this task's status as it works. Use this when executing a persistent task from the task board."
+        )
       })
     }
   );
@@ -11897,7 +12686,7 @@ function getMainAgentFromConfig(config) {
   });
 }
 function createCheckAsyncTaskTool() {
-  return tool39(
+  return tool40(
     async (input, config) => {
       const { task_id } = input;
       const mainAgent = getMainAgentFromConfig(config);
@@ -11957,14 +12746,14 @@ Description: ${cached.description}`;
     {
       name: "check_async_task",
       description: "Get the current status and result of an async background task. Use this to check if a previously launched async task has completed.",
-      schema: z42.object({
-        task_id: z42.string().describe("The task ID returned when the async task was started")
+      schema: z43.object({
+        task_id: z43.string().describe("The task ID returned when the async task was started")
       })
     }
   );
 }
 function createListAsyncTasksTool() {
-  return tool39(
+  return tool40(
     async (_input, config) => {
       const mainAgent = getMainAgentFromConfig(config);
       if (!mainAgent) {
@@ -12010,12 +12799,12 @@ function createListAsyncTasksTool() {
     {
       name: "list_async_tasks",
       description: "List all async background tasks with their current status. Use this before reporting task status to the user. Statuses in conversation history may be stale.",
-      schema: z42.object({})
+      schema: z43.object({})
     }
   );
 }
 function createCancelAsyncTaskTool() {
-  return tool39(
+  return tool40(
     async (input, config) => {
       const { task_id } = input;
       const mainAgent = getMainAgentFromConfig(config);
@@ -12054,8 +12843,8 @@ function createCancelAsyncTaskTool() {
     {
       name: "cancel_async_task",
       description: "Cancel a running async background task.",
-      schema: z42.object({
-        task_id: z42.string().describe("The task ID to cancel")
+      schema: z43.object({
+        task_id: z43.string().describe("The task ID to cancel")
       })
     }
   );
@@ -12091,7 +12880,7 @@ function createSubAgentMiddleware(options) {
     );
   }
   const effectiveSystemPrompt = allowAsync ? systemPrompt + getAsyncPromptText() : systemPrompt;
-  return createMiddleware9({
+  return createMiddleware10({
     name: "subAgentMiddleware",
     tools: allTools,
     wrapModelCall: async (request, handler) => {
@@ -12112,12 +12901,12 @@ ${effectiveSystemPrompt}` : effectiveSystemPrompt;
 
 // src/deep_agent_new/middleware/patch_tool_calls.ts
 import {
-  createMiddleware as createMiddleware10,
+  createMiddleware as createMiddleware11,
   ToolMessage as ToolMessage4,
   AIMessage as AIMessage2
 } from "langchain";
 function createPatchToolCallsMiddleware() {
-  return createMiddleware10({
+  return createMiddleware11({
     name: "patchToolCallsMiddleware",
     beforeAgent: async (state) => {
       const messages = state.messages;
@@ -12158,8 +12947,8 @@ function createPatchToolCallsMiddleware() {
 }
 
 // src/deep_agent_new/middleware/date.ts
-import { createMiddleware as createMiddleware11, tool as tool40 } from "langchain";
-import { z as z43 } from "zod";
+import { createMiddleware as createMiddleware12, tool as tool41 } from "langchain";
+import { z as z44 } from "zod";
 function formatCurrentDate(timezone = "UTC") {
   const now = /* @__PURE__ */ new Date();
   let validTimezone = timezone;
@@ -12187,10 +12976,10 @@ function generateDateContext(timezone = "UTC") {
 function createDateMiddleware(options = {}) {
   const timezone = options.timezone || "UTC";
   const dateContext = generateDateContext(timezone);
-  return createMiddleware11({
+  return createMiddleware12({
     name: "DateMiddleware",
     tools: [
-      tool40(
+      tool41(
         async () => {
           const now = /* @__PURE__ */ new Date();
           let validTimezone = timezone;
@@ -12220,7 +13009,7 @@ function createDateMiddleware(options = {}) {
         {
           name: "get_current_date_time",
           description: "Get the exact current date and time at the moment of invocation. Use this when the user asks about the current time (e.g., 'what time is it', '\u51E0\u70B9\u4E86', '\u73B0\u5728\u51E0\u70B9'), or when you need to know the precise time for scheduling, deadlines, or time-sensitive operations.",
-          schema: z43.object({})
+          schema: z44.object({})
         }
       )
     ],
@@ -12285,8 +13074,8 @@ var datePlugin = {
 };
 
 // src/deep_agent_new/middleware/scheduler.ts
-import { tool as tool41, createMiddleware as createMiddleware12 } from "langchain";
-import { z as z44 } from "zod";
+import { tool as tool42, createMiddleware as createMiddleware13 } from "langchain";
+import { z as z45 } from "zod";
 import { v4 as uuidv43 } from "uuid";
 import { ScheduledTaskStatus as ScheduledTaskStatus3, ScheduleExecutionType as ScheduleExecutionType3 } from "@axiom-lattice/protocols";
 
@@ -13288,7 +14077,7 @@ var getScheduleLattice = (key4) => scheduleLatticeManager.getScheduleLattice(key
 // src/deep_agent_new/middleware/scheduler.ts
 var SCHEDULE_LATTICE_KEY = "default";
 var AGENT_ADD_MESSAGE_TASK_TYPE = "agent.add_message";
-function getRunConfig(config) {
+function getRunConfig2(config) {
   const configurable = config;
   return configurable?.configurable?.runConfig ?? {};
 }
@@ -13360,12 +14149,12 @@ function registerAgentAddMessageHandler() {
 function createSchedulerMiddleware(options = {}) {
   const defaultMaxRetries = options.defaultMaxRetries ?? 0;
   registerAgentAddMessageHandler();
-  return createMiddleware12({
+  return createMiddleware13({
     name: "SchedulerMiddleware",
     tools: [
-      tool41(
+      tool42(
         async (input, config) => {
-          const runConfig = getRunConfig(config);
+          const runConfig = getRunConfig2(config);
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
           const taskId = uuidv43();
           const executeAt = input.executeAt;
@@ -13391,16 +14180,16 @@ function createSchedulerMiddleware(options = {}) {
         {
           name: "schedule_at",
           description: "Schedule a system message for an absolute future timestamp",
-          schema: z44.object({
-            executeAt: z44.number(),
-            maxRetries: z44.number().int().min(0).optional(),
-            message: z44.string()
+          schema: z45.object({
+            executeAt: z45.number(),
+            maxRetries: z45.number().int().min(0).optional(),
+            message: z45.string()
           })
         }
       ),
-      tool41(
+      tool42(
         async (input, config) => {
-          const runConfig = getRunConfig(config);
+          const runConfig = getRunConfig2(config);
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
           const taskId = uuidv43();
           const executeAt = Date.now() + input.delayMs;
@@ -13426,16 +14215,16 @@ function createSchedulerMiddleware(options = {}) {
         {
           name: "schedule_after",
           description: "Schedule a system message after a relative delay",
-          schema: z44.object({
-            delayMs: z44.number().positive(),
-            maxRetries: z44.number().int().min(0).optional(),
-            message: z44.string()
+          schema: z45.object({
+            delayMs: z45.number().positive(),
+            maxRetries: z45.number().int().min(0).optional(),
+            message: z45.string()
           })
         }
       ),
-      tool41(
+      tool42(
         async (input, config) => {
-          const runConfig = getRunConfig(config);
+          const runConfig = getRunConfig2(config);
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
           const taskId = uuidv43();
           const success = await scheduleLattice.client.scheduleCron(
@@ -13468,16 +14257,16 @@ function createSchedulerMiddleware(options = {}) {
         {
           name: "schedule_recurring",
           description: "Schedule a recurring system message with a cron expression",
-          schema: z44.object({
-            cronExpression: z44.string(),
-            maxRuns: z44.number().int().positive().optional(),
-            expiresAt: z44.number().optional(),
-            maxRetries: z44.number().int().min(0).optional(),
-            message: z44.string()
+          schema: z45.object({
+            cronExpression: z45.string(),
+            maxRuns: z45.number().int().positive().optional(),
+            expiresAt: z45.number().optional(),
+            maxRetries: z45.number().int().min(0).optional(),
+            message: z45.string()
           })
         }
       ),
-      tool41(
+      tool42(
         async (input) => {
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
           const success = await scheduleLattice.client.cancel(input.taskId);
@@ -13486,14 +14275,14 @@ function createSchedulerMiddleware(options = {}) {
         {
           name: "cancel_scheduled_task",
           description: "Cancel a scheduled task by task id",
-          schema: z44.object({
-            taskId: z44.string()
+          schema: z45.object({
+            taskId: z45.string()
           })
         }
       ),
-      tool41(
+      tool42(
         async (input, config) => {
-          const runConfig = getRunConfig(config);
+          const runConfig = getRunConfig2(config);
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
           const storage = scheduleLattice.client.getStorage();
           if (!storage) {
@@ -13513,11 +14302,11 @@ function createSchedulerMiddleware(options = {}) {
         {
           name: "list_scheduled_tasks",
           description: "List scheduled tasks for the current agent context",
-          schema: z44.object({
-            status: z44.enum(["pending", "running", "completed", "failed", "cancelled", "paused"]).optional(),
-            executionType: z44.enum(["once", "cron"]).optional(),
-            limit: z44.number().int().positive().optional(),
-            offset: z44.number().int().min(0).optional()
+          schema: z45.object({
+            status: z45.enum(["pending", "running", "completed", "failed", "cancelled", "paused"]).optional(),
+            executionType: z45.enum(["once", "cron"]).optional(),
+            limit: z45.number().int().positive().optional(),
+            offset: z45.number().int().min(0).optional()
           })
         }
       )
@@ -14658,8 +15447,8 @@ var MemoryBackend = class {
 
 // src/deep_agent_new/middleware/todos.ts
 import { Command as Command4 } from "@langchain/langgraph";
-import { z as z45 } from "zod";
-import { createMiddleware as createMiddleware13, tool as tool42, ToolMessage as ToolMessage5 } from "langchain";
+import { z as z46 } from "zod";
+import { createMiddleware as createMiddleware14, tool as tool43, ToolMessage as ToolMessage5 } 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.
@@ -14886,14 +15675,14 @@ Writing todos takes time and tokens, use it when it is helpful for managing comp
 ## 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 = z45.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
-var TodoSchema = z45.object({
-  content: z45.string().describe("Content of the todo item"),
+var TodoStatus = z46.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
+var TodoSchema = z46.object({
+  content: z46.string().describe("Content of the todo item"),
   status: TodoStatus
 });
-var stateSchema = z45.object({ todos: z45.array(TodoSchema).default([]) });
+var stateSchema = z46.object({ todos: z46.array(TodoSchema).default([]) });
 function todoListMiddleware(options) {
-  const writeTodos = tool42(
+  const writeTodos = tool43(
     ({ todos }, config) => {
       return new Command4({
         update: {
@@ -14910,12 +15699,12 @@ function todoListMiddleware(options) {
     {
       name: "write_todos",
       description: options?.toolDescription ?? WRITE_TODOS_DESCRIPTION,
-      schema: z45.object({
-        todos: z45.array(TodoSchema).describe("List of todo items to update")
+      schema: z46.object({
+        todos: z46.array(TodoSchema).describe("List of todo items to update")
       })
     }
   );
-  return createMiddleware13({
+  return createMiddleware14({
     name: "todoListMiddleware",
     stateSchema,
     tools: [writeTodos],
@@ -15068,7 +15857,7 @@ var DeepAgentGraphBuilder = class {
 };
 
 // src/agent_team/agent_team.ts
-import { z as z48 } from "zod/v3";
+import { z as z49 } from "zod/v3";
 import { createAgent as createAgent5 } from "langchain";
 
 // src/agent_team/types.ts
@@ -15504,14 +16293,14 @@ var InMemoryMailboxStore = class {
 };
 
 // src/agent_team/middleware/team.ts
-import { z as z47 } from "zod/v3";
-import { createMiddleware as createMiddleware14, createAgent as createAgent4, tool as tool44, ToolMessage as ToolMessage7 } from "langchain";
+import { z as z48 } from "zod/v3";
+import { createMiddleware as createMiddleware15, createAgent as createAgent4, tool as tool45, ToolMessage as ToolMessage7 } from "langchain";
 import { Command as Command6, getCurrentTaskInput as getCurrentTaskInput3 } from "@langchain/langgraph";
 import { v4 as uuidv44 } from "uuid";
 
 // src/agent_team/middleware/teammate_tools.ts
-import { z as z46 } from "zod/v3";
-import { tool as tool43, ToolMessage as ToolMessage6 } from "langchain";
+import { z as z47 } from "zod/v3";
+import { tool as tool44, ToolMessage as ToolMessage6 } from "langchain";
 import { Command as Command5 } from "@langchain/langgraph";
 
 // src/agent_team/middleware/formatMessages.ts
@@ -15536,7 +16325,7 @@ ${meta}${body}`;
 // src/agent_team/middleware/teammate_tools.ts
 function createTeammateTools(options) {
   const { teamId, agentId, taskListStore, mailboxStore } = options;
-  const claimTaskTool = tool43(
+  const claimTaskTool = tool44(
     async (input) => {
       const task = await taskListStore.claimTaskById(
         teamId,
@@ -15561,12 +16350,12 @@ function createTeammateTools(options) {
     {
       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: z46.object({
-        task_id: z46.string().describe("ID of the task to claim (e.g. task-01). Use check_tasks to see IDs.")
+      schema: z47.object({
+        task_id: z47.string().describe("ID of the task to claim (e.g. task-01). Use check_tasks to see IDs.")
       })
     }
   );
-  const completeTaskTool = tool43(
+  const completeTaskTool = tool44(
     async (input) => {
       const task = await taskListStore.completeTask(
         teamId,
@@ -15587,13 +16376,13 @@ function createTeammateTools(options) {
     {
       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: z46.object({
-        task_id: z46.string().describe("ID of the task to complete"),
-        result: z46.string().describe("Summary of the task result")
+      schema: z47.object({
+        task_id: z47.string().describe("ID of the task to complete"),
+        result: z47.string().describe("Summary of the task result")
       })
     }
   );
-  const failTaskTool = tool43(
+  const failTaskTool = tool44(
     async (input) => {
       const task = await taskListStore.failTask(
         teamId,
@@ -15614,13 +16403,13 @@ function createTeammateTools(options) {
     {
       name: "fail_task",
       description: "Mark a claimed task as failed with an error description. Call this if you cannot complete the task.",
-      schema: z46.object({
-        task_id: z46.string().describe("ID of the task to fail"),
-        error: z46.string().describe("Description of why the task failed")
+      schema: z47.object({
+        task_id: z47.string().describe("ID of the task to fail"),
+        error: z47.string().describe("Description of why the task failed")
       })
     }
   );
-  const sendMessageTool = tool43(
+  const sendMessageTool = tool44(
     async (input) => {
       await mailboxStore.sendMessage(
         teamId,
@@ -15634,11 +16423,11 @@ function createTeammateTools(options) {
     {
       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: z46.object({
-        to: z46.string().describe(
+      schema: z47.object({
+        to: z47.string().describe(
           'Recipient agent name (e.g. "team_lead" or a teammate name)'
         ),
-        content: z46.string().describe("Message content")
+        content: z47.string().describe("Message content")
       })
     }
   );
@@ -15658,7 +16447,7 @@ function createTeammateTools(options) {
       read: msg.read
     }));
   };
-  const readMessagesTool = tool43(
+  const readMessagesTool = tool44(
     async (input, config) => {
       const formatAndMarkAsRead = async (msgs2) => {
         for (const msg of msgs2) {
@@ -15717,10 +16506,10 @@ function createTeammateTools(options) {
     {
       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: z46.object({})
+      schema: z47.object({})
     }
   );
-  const checkTasksTool = tool43(
+  const checkTasksTool = tool44(
     async () => {
       const tasks = await taskListStore.getAllTasks(teamId);
       return formatTaskSummary(tasks);
@@ -15728,10 +16517,10 @@ function createTeammateTools(options) {
     {
       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: z46.object({})
+      schema: z47.object({})
     }
   );
-  const broadcastMessageTool = tool43(
+  const broadcastMessageTool = tool44(
     async (input) => {
       const allAgents = await mailboxStore.getRegisteredAgents(teamId);
       const recipients = allAgents.filter((a) => a !== agentId);
@@ -15750,8 +16539,8 @@ function createTeammateTools(options) {
     {
       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: z46.object({
-        content: z46.string().describe("Message content to broadcast to others")
+      schema: z47.object({
+        content: z47.string().describe("Message content to broadcast to others")
       })
     }
   );
@@ -15985,7 +16774,7 @@ async function spawnTeammate(options) {
 function createTeamMiddleware(options) {
   const { teamConfig, taskListStore, mailboxStore, tenantId: tenantId2 } = options;
   const defaultModel = teamConfig.model ?? "claude-sonnet-4-5-20250929";
-  const createTeamTool = tool44(
+  const createTeamTool = tool45(
     async (input, config) => {
       const state = getCurrentTaskInput3();
       if (state?.team?.teamId) {
@@ -16140,20 +16929,20 @@ After calling create_team, you MUST:
 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: z47.object({
-        tasks: z47.array(
-          z47.object({
-            id: z47.string().describe("Task ID in format task-01, task-02, etc."),
-            title: z47.string().describe("Short task title"),
-            description: z47.string().describe("Detailed task description - what exactly needs to be done"),
-            dependencies: z47.array(z47.string()).optional().default([]).describe('Array of task IDs that must complete before this task (e.g. ["task-01"])')
+      schema: z48.object({
+        tasks: z48.array(
+          z48.object({
+            id: z48.string().describe("Task ID in format task-01, task-02, etc."),
+            title: z48.string().describe("Short task title"),
+            description: z48.string().describe("Detailed task description - what exactly needs to be done"),
+            dependencies: z48.array(z48.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: z47.array(
-          z47.object({
-            name: z47.string().describe("Teammate name (must match a pre-configured teammate type)"),
-            role: z47.string().describe("Role category (e.g. researcher, writer, coder, reviewer)"),
-            description: z47.string().describe("What this teammate will focus on - specific instructions for their work")
+        teammates: z48.array(
+          z48.object({
+            name: z48.string().describe("Teammate name (must match a pre-configured teammate type)"),
+            role: z48.string().describe("Role category (e.g. researcher, writer, coder, reviewer)"),
+            description: z48.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.")
       })
@@ -16164,7 +16953,7 @@ After calling create_team, you MUST:
     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 = tool44(
+  const addTasksTool = tool45(
     async (input, config) => {
       const teamId = resolveTeamId();
       const created = await taskListStore.addTasks(
@@ -16216,20 +17005,20 @@ IMPORTANT: Dependencies
 
 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: z47.object({
-        tasks: z47.array(
-          z47.object({
-            id: z47.string().describe("Task ID in format task-01, task-02, etc. Must be unique."),
-            title: z47.string().describe("Short task title"),
-            description: z47.string().describe("Detailed task description - what needs to be done"),
-            assignee: z47.string().optional().describe("Teammate name to assign this task to (use when you need that person to do the work)"),
-            dependencies: z47.array(z47.string()).optional().default([]).describe("Array of task IDs that must complete before this task")
+      schema: z48.object({
+        tasks: z48.array(
+          z48.object({
+            id: z48.string().describe("Task ID in format task-01, task-02, etc. Must be unique."),
+            title: z48.string().describe("Short task title"),
+            description: z48.string().describe("Detailed task description - what needs to be done"),
+            assignee: z48.string().optional().describe("Teammate name to assign this task to (use when you need that person to do the work)"),
+            dependencies: z48.array(z48.string()).optional().default([]).describe("Array of task IDs that must complete before this task")
           })
         ).describe("New tasks to add to the team")
       })
     }
   );
-  const assignTaskTool = tool44(
+  const assignTaskTool = tool45(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
@@ -16251,13 +17040,13 @@ IMPORTANT: Assigning to a specific teammate
     {
       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: z47.object({
-        task_id: z47.string().describe("Task ID to assign"),
-        assignee: z47.string().describe("Teammate name to assign this task to")
+      schema: z48.object({
+        task_id: z48.string().describe("Task ID to assign"),
+        assignee: z48.string().describe("Teammate name to assign this task to")
       })
     }
   );
-  const setTaskStatusTool = tool44(
+  const setTaskStatusTool = tool45(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
@@ -16279,13 +17068,13 @@ IMPORTANT: Assigning to a specific teammate
     {
       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: z47.object({
-        task_id: z47.string().describe("Task ID to update"),
-        status: z47.enum(["pending", "claimed", "in_progress", "completed", "failed"]).describe("New status for the task")
+      schema: z48.object({
+        task_id: z48.string().describe("Task ID to update"),
+        status: z48.enum(["pending", "claimed", "in_progress", "completed", "failed"]).describe("New status for the task")
       })
     }
   );
-  const setTaskDependenciesTool = tool44(
+  const setTaskDependenciesTool = tool45(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
@@ -16307,13 +17096,13 @@ IMPORTANT: Assigning to a specific teammate
     {
       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: z47.object({
-        task_id: z47.string().describe("Task ID to update"),
-        dependencies: z47.array(z47.string()).describe("Task IDs that must complete before this task can be claimed")
+      schema: z48.object({
+        task_id: z48.string().describe("Task ID to update"),
+        dependencies: z48.array(z48.string()).describe("Task IDs that must complete before this task can be claimed")
       })
     }
   );
-  const checkTasksTool = tool44(
+  const checkTasksTool = tool45(
     async (input, config) => {
       const teamId = resolveTeamId();
       const tasks = await taskListStore.getAllTasks(teamId);
@@ -16353,12 +17142,12 @@ Task Status Values:
 - in_progress: Teammate is actively working on this task
 - completed: Task finished successfully
 - failed: Task encountered an error`,
-      schema: z47.object({
-        team_id: z47.string().optional().describe("Team ID (omit to use active team)")
+      schema: z48.object({
+        team_id: z48.string().optional().describe("Team ID (omit to use active team)")
       })
     }
   );
-  const sendMessageTool = tool44(
+  const sendMessageTool = tool45(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.sendMessage(
@@ -16377,13 +17166,13 @@ Task Status Values:
     {
       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: z47.object({
-        to: z47.string().describe("Recipient teammate name"),
-        content: z47.string().describe("Message content")
+      schema: z48.object({
+        to: z48.string().describe("Recipient teammate name"),
+        content: z48.string().describe("Message content")
       })
     }
   );
-  const readMessagesTool = tool44(
+  const readMessagesTool = tool45(
     async (input, config) => {
       const teamId = resolveTeamId();
       const formatAndMarkAsRead = async (msgs2) => {
@@ -16465,12 +17254,12 @@ Task Status Values:
     {
       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: z47.object({
-        team_id: z47.string().optional().describe("Team ID (omit to use active team)")
+      schema: z48.object({
+        team_id: z48.string().optional().describe("Team ID (omit to use active team)")
       })
     }
   );
-  const disbandTeamTool = tool44(
+  const disbandTeamTool = tool45(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -16491,7 +17280,7 @@ Task Status Values:
       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 = tool44(
+  const broadcastMessageTool = tool45(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -16509,12 +17298,12 @@ Task Status Values:
     {
       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: z47.object({
-        content: z47.string().describe("Message content to broadcast to all teammates")
+      schema: z48.object({
+        content: z48.string().describe("Message content to broadcast to all teammates")
       })
     }
   );
-  return createMiddleware14({
+  return createMiddleware15({
     name: "teamMiddleware",
     tools: [
       createTeamTool,
@@ -16542,37 +17331,37 @@ ${TEAM_SYSTEM_PROMPT}` : TEAM_SYSTEM_PROMPT;
 }
 
 // src/agent_team/agent_team.ts
-var TeammateInfoSchema = z48.object({
-  name: z48.string().describe("Teammate name"),
-  role: z48.string().describe("Role category (e.g. research, writing, review)"),
-  description: z48.string().describe("What this teammate focuses on")
+var TeammateInfoSchema = z49.object({
+  name: z49.string().describe("Teammate name"),
+  role: z49.string().describe("Role category (e.g. research, writing, review)"),
+  description: z49.string().describe("What this teammate focuses on")
 });
-var TeamTaskInfoSchema = z48.object({
-  id: z48.string(),
-  title: z48.string(),
-  description: z48.string(),
-  status: z48.string().optional()
+var TeamTaskInfoSchema = z49.object({
+  id: z49.string(),
+  title: z49.string(),
+  description: z49.string(),
+  status: z49.string().optional()
 });
-var MailboxMessageSchema = z48.object({
-  id: z48.string().describe("Unique message identifier"),
-  from: z48.string().describe("Sender agent name"),
-  to: z48.string().describe("Recipient agent name"),
-  content: z48.string().describe("Message content"),
-  timestamp: z48.string().describe("ISO timestamp when the message was sent"),
-  type: z48.nativeEnum(MessageType).describe("Message type"),
-  read: z48.boolean().describe("Whether the recipient has read this message")
+var MailboxMessageSchema = z49.object({
+  id: z49.string().describe("Unique message identifier"),
+  from: z49.string().describe("Sender agent name"),
+  to: z49.string().describe("Recipient agent name"),
+  content: z49.string().describe("Message content"),
+  timestamp: z49.string().describe("ISO timestamp when the message was sent"),
+  type: z49.nativeEnum(MessageType).describe("Message type"),
+  read: z49.boolean().describe("Whether the recipient has read this message")
 });
-var TeamInfoSchema = z48.object({
-  teamId: z48.string().describe("Unique team identifier"),
-  teamLeadId: z48.string().default("team_lead").describe("Team lead agent ID"),
-  teammates: z48.array(TeammateInfoSchema).describe("Active teammates in this team"),
-  tasks: z48.array(TeamTaskInfoSchema).optional().describe("Initial tasks snapshot"),
-  createdAt: z48.string().optional().describe("ISO timestamp when team was created")
+var TeamInfoSchema = z49.object({
+  teamId: z49.string().describe("Unique team identifier"),
+  teamLeadId: z49.string().default("team_lead").describe("Team lead agent ID"),
+  teammates: z49.array(TeammateInfoSchema).describe("Active teammates in this team"),
+  tasks: z49.array(TeamTaskInfoSchema).optional().describe("Initial tasks snapshot"),
+  createdAt: z49.string().optional().describe("ISO timestamp when team was created")
 });
-var TEAM_STATE_SCHEMA = z48.object({
+var TEAM_STATE_SCHEMA = z49.object({
   team: TeamInfoSchema.optional().describe("Team info: teamId, teamLeadId, teammates, tasks. Set when create_team succeeds."),
-  tasks: z48.array(TeamTaskInfoSchema).optional().describe("Current tasks snapshot from check_tasks. Updated on each check."),
-  team_mailbox: z48.array(MailboxMessageSchema).optional().describe("All team mailbox messages for display")
+  tasks: z49.array(TeamTaskInfoSchema).optional().describe("Current tasks snapshot from check_tasks. Updated on each check."),
+  team_mailbox: z49.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:
 
@@ -16695,7 +17484,7 @@ import { StateGraph as StateGraph2, MessagesAnnotation } from "@langchain/langgr
 import { AIMessage as AIMessage3 } from "@langchain/core/messages";
 
 // src/services/a2a-client.ts
-import { v4 as v42 } from "uuid";
+import { v4 as v43 } from "uuid";
 var A2ARemoteError = class extends Error {
   constructor(message, statusCode, body) {
     super(message);
@@ -16742,7 +17531,7 @@ var A2ARemoteClient = class {
    */
   async sendMessage(text) {
     await this.resolve();
-    const taskId = v42();
+    const taskId = v43();
     const body = JSON.stringify({
       jsonrpc: "2.0",
       method: "tasks/send",
@@ -17528,6 +18317,22 @@ async function configureStores(stores, options = {}) {
       storeLatticeManager.registerLattice("default", t, store);
     }
   }
+  if (options.discoverPlugins) {
+    const pluginTypes = PluginRegistry.list();
+    for (const pluginType of pluginTypes) {
+      const plugin = PluginRegistry.get(pluginType);
+      if (!plugin?.stores) continue;
+      for (const [storeType, storeOrFactory] of Object.entries(plugin.stores)) {
+        const store = typeof storeOrFactory === "function" ? storeOrFactory() : storeOrFactory;
+        await initAndRegister(store, localDisposables);
+        const t = storeType;
+        if (storeLatticeManager.hasLattice("default", t)) {
+          storeLatticeManager.removeLattice("default", t);
+        }
+        storeLatticeManager.registerLattice("default", t, store);
+      }
+    }
+  }
   if (options.autoDisposeStores) {
     registerSignalCleanup();
     _disposables.push(...localDisposables);
@@ -17672,7 +18477,7 @@ description: Create new skills, modify and improve existing skills. Use this ski
 license: MIT
 metadata:
   category: meta
-  version: "2.0"
+  version: "3.0"
 ---
 
 # Skill Creator
@@ -17771,6 +18576,160 @@ Instructional content for the agent.
 
 ---
 
+## subSkills: Building the Skill Graph
+
+\`subSkills\` is how skills reference each other. It forms a graph \u2014
+visualized in the Skills view as connected nodes.
+
+### What subSkills Means
+
+It declares: "this skill is conceptually composed of these sub-skills."
+It does NOT mean the agent automatically loads them. The agent reads the
+body and decides what to load next.
+
+### When to Use subSkills
+
+**YES \u2014 split into subSkills when another task would independently
+reference that piece.** The test:
+
+> "Will a future learning task about a DIFFERENT document type
+> need to reference this?"
+
+For example:
+- \`engine-selection\` \u2192 YES, PO extraction AND invoice extraction both need it
+- \`sap-bp-validation\` \u2192 YES, multiple tasks validate BP through SAP
+- \`po-bp-extraction\` \u2192 NO, nobody extracts BP without extracting the whole PO
+
+**NO \u2014 keep in one file when the steps are a single pipeline that's
+always used together.** Field extraction, validation, and formatting
+for one document type belong in one skill file.
+
+### Examples
+
+Good (shared skills split out):
+\`\`\`yaml
+---
+name: po-extraction
+description: Extract BP, items, notes from PO PDFs with SAP validation
+subSkills:
+  - engine-selection       # Shared \u2014 also used by invoice-extraction
+---
+# Body describes the full PO extraction flow:
+# 1. Use [[engine-selection]] to pick best parser
+# 2. Find BP in document header
+# 3. Parse items table
+# ...
+
+---
+name: engine-selection
+description: Choose the best parsing engine based on document type
+---
+# Body describes decision logic with confidence scores
+\`\`\`
+
+Bad (over-split \u2014 these are never used independently):
+\`\`\`yaml
+---
+name: po-bp-extraction
+description: Extract BP field from PO
+subSkills: []
+---
+# This is always used with items-extraction and notes-extraction.
+# They should be one skill: po-extraction
+\`\`\`
+
+### Growing the Graph
+
+Skills are discovered incrementally. When a learning task produces
+new knowledge:
+
+1. \`ls /root/.agents/knowledge/\` to see what already exists
+2. If a reusable piece already exists \u2192 reference it via subSkills
+3. If a reusable piece doesn't exist \u2192 create it, then reference it
+4. If it's not reusable \u2192 keep it in the parent skill's body
+
+The graph grows naturally \u2014 each new learning task adds nodes
+and edges by creating skills and declaring subSkills.
+
+---
+
+## Verifying subSkills Are Correct
+
+After writing the body, check consistency between frontmatter and content.
+You MUST run these checks before finalizing the skill.
+
+### Self-Check Rules
+
+**For each entry in subSkills:**
+Find where in the body it's actually referenced. If you can't find it \u2014
+either the body is missing the reference, or the subSkill shouldn't
+be there.
+
+**For each skill referenced in the body:**
+Check that it appears in subSkills. If the body references a skill
+but subSkills doesn't list it \u2014 add it.
+
+### Automated Consistency Check
+
+Since body references use \`[[skill-name]]\` format, you can verify
+automatically:
+
+\`\`\`bash
+# Extract all skill references from body
+grep -oE '\\[\\[[^]]+\\]\\]' /root/.agents/skills/{skill-name}/SKILL.md \\
+  | sed 's/\\[\\[//;s/\\]\\]//' | sort -u
+
+# Then compare with the subSkills list in frontmatter.
+# Every [[ref]] in body should have a corresponding subSkills entry.
+# Every subSkills entry should appear as [[ref]] somewhere in body.
+\`\`\`
+
+### Quick Checklist Before Writing
+
+1. List all subSkills in frontmatter
+2. grep the body for each name using \`[[name]]\` format \u2014 does it appear?
+3. grep the body for \`[[...]]\` patterns \u2014 are they all in subSkills?
+4. Mismatches \u2192 fix either the body or the frontmatter
+5. Remove any subSkills entry that's never referenced in the body
+
+---
+
+## Referencing Other Skills in the Body
+
+When the body instructs the agent to consult another skill,
+use the \`[[skill-name]]\` format:
+
+\`\`\`markdown
+## Procedure
+
+1. First, use [[engine-selection]] to pick the best parsing engine
+2. Load [[sap-bp-validation]] to verify the extracted Business Partner
+3. For edge cases, refer to [[ocr-fallback]]
+
+## Dependencies
+
+This skill depends on:
+- [[engine-selection]] \u2014 chooses the parsing engine
+- [[sap-bp-validation]] \u2014 validates BP codes against SAP
+\`\`\`
+
+### Why [[wiki-links]]
+
+- **Visually distinct** \u2014 clearly not regular text
+- **Grepable** \u2014 \`grep -o '\\[\\[.*?\\]\\]'\` extracts all references
+- **Verifiable** \u2014 the consistency check against subSkills can be automated
+- **Human-readable** \u2014 anyone reading the SKILL.md knows this is a skill reference
+
+### Rules
+- Always use the exact skill name (kebab-case) inside \`[[]]\`
+- Before writing, check each referenced skill:
+  - If it exists \u2014 reference it directly
+  - If it doesn't exist \u2014 create it first, then reference it in the parent
+- Every \`[[ref]]\` in the body must have a corresponding \`subSkills\` entry
+- Every \`subSkills\` entry must appear as \`[[ref]]\` somewhere in the body
+
+---
+
 ## Writing Guide
 
 ### The Description Field
@@ -17821,6 +18780,7 @@ A well-written skill body typically includes:
 - **Guidelines**: Rules, constraints, quality standards, and the WHY behind them
 - **Scenarios**: 2-3 common scenarios with concrete examples of inputs and expected outputs
 - **Edge cases**: What to do when things go wrong, when data is missing, etc.
+- **Skill references**: Use \`[[skill-name]]\` to reference other skills \u2014 see the subSkills section above
 
 ---
 
@@ -17828,10 +18788,11 @@ A well-written skill body typically includes:
 
 After writing the draft, test it:
 
-1. **Create 2-3 test prompts** \u2014 the kind of thing a real user would actually say. Share them with the user: "Here are a few test cases I'd like to try. Do these look right?"
-2. **Run the skill** against each test prompt to see what the agent produces
-3. **Review outputs with the user**: evaluate both qualitatively (does the output look right?) and quantitatively (did it follow the workflow? use the right tools?)
-4. **Collect feedback**: What worked? What didn't? What surprised the user?
+1. **Run the consistency check** from the Verifying subSkills section \u2014 fix any mismatches
+2. **Create 2-3 test prompts** \u2014 the kind of thing a real user would actually say. Share them with the user: "Here are a few test cases I'd like to try. Do these look right?"
+3. **Run the skill** against each test prompt to see what the agent produces
+4. **Review outputs with the user**: evaluate both qualitatively (does the output look right?) and quantitatively (did it follow the workflow? use the right tools?)
+5. **Collect feedback**: What worked? What didn't? What surprised the user?
 
 ### Improving the Skill
 
@@ -17867,10 +18828,11 @@ The agent sees skills as a list of name + description pairs. It decides whether
 ## Step 6: Package and Present
 
 When the skill is ready:
-1. Verify the SKILL.md is at \`/root/.agents/skills/{skill-name}/SKILL.md\` with correct frontmatter
-2. Confirm all resource files are in place under \`resources/\`
-3. Tell the user the skill is ready and available at its path
-4. Remind them that the skill will now appear in the available skills list for any agent using the skill system
+1. Run the subSkills consistency check one final time
+2. Verify the SKILL.md is at \`/root/.agents/skills/{skill-name}/SKILL.md\` with correct frontmatter
+3. Confirm all resource files are in place under \`resources/\`
+4. Tell the user the skill is ready and available at its path
+5. Remind them that the skill will now appear in the available skills list for any agent using the skill system
 
 ## Updating Existing Skills
 
@@ -17879,7 +18841,8 @@ When the user wants to improve an existing skill:
 2. Understand what it currently does and where it falls short
 3. Follow the same interview \u2192 draft \u2192 test \u2192 iterate loop
 4. **Preserve the original name** \u2014 the directory name and \`name\` frontmatter field should stay the same
-5. Write the updated version back to the same path
+5. Run the subSkills consistency check after making changes
+6. Write the updated version back to the same path
 
 ---
 
@@ -17913,6 +18876,8 @@ metadata:
 
 **You** (write): Create \`/root/.agents/skills/csv-analyzer/SKILL.md\`
 
+**You** (verify): Run the subSkills consistency check \u2014 no subSkills, no \`[[refs]]\`, all good.
+
 **You** (test): "Here are 3 test cases \u2014 'summarize this sales CSV', 'filter rows where region is West', 'show monthly revenue trends'. Let me run these and we'll review."
 
 Then iterate based on what the user says.
@@ -18972,8 +19937,8 @@ var InMemoryMenuStore = class {
 };
 
 // src/agent_lattice/agentArchitectTools.ts
-import z49 from "zod";
-import { v4 as v43 } from "uuid";
+import z50 from "zod";
+import { v4 as v44 } from "uuid";
 import { AgentType as AgentType3 } from "@axiom-lattice/protocols";
 function getTenantId(exeConfig) {
   const runConfig = exeConfig?.configurable?.runConfig || {};
@@ -19002,7 +19967,7 @@ registerToolLattice(
   {
     name: "list_agents",
     description: "List all agents for the current workspace. Returns a summary with id, name, description, and type for each agent.",
-    schema: z49.object({})
+    schema: z50.object({})
   },
   async (_input, exeConfig) => {
     try {
@@ -19029,8 +19994,8 @@ registerToolLattice(
   {
     name: "get_agent",
     description: "Get the full configuration of a specific agent by its ID. Returns the complete AgentConfig including prompt, middleware, tools, and sub-agents.",
-    schema: z49.object({
-      id: z49.string().describe("The agent ID to retrieve")
+    schema: z50.object({
+      id: z50.string().describe("The agent ID to retrieve")
     })
   },
   async (input, exeConfig) => {
@@ -19047,24 +20012,24 @@ registerToolLattice(
     }
   }
 );
-var middlewareConfigSchema = z49.object({
-  id: z49.string(),
-  type: z49.string(),
-  name: z49.string(),
-  description: z49.string(),
-  enabled: z49.boolean(),
-  config: z49.record(z49.any()).optional()
+var middlewareConfigSchema = z50.object({
+  id: z50.string(),
+  type: z50.string(),
+  name: z50.string(),
+  description: z50.string(),
+  enabled: z50.boolean(),
+  config: z50.record(z50.any()).optional()
 });
-var createAgentSchema = z49.object({
-  name: z49.string().describe("Human-friendly display name for the agent. The machine ID (used in other tools) is auto-generated as a slug from this name (e.g. 'My Cool Agent' \u2192 'my-cool-agent')."),
-  description: z49.string().optional().describe("Short description"),
-  type: z49.enum(["react", "deep_agent"]).describe("Agent type. Use 'react' for simple single-responsibility agents, 'deep_agent' for complex open-ended agents. For PROCESSING agents (workflow orchestration), use create_processing_agent instead."),
-  prompt: z49.string().describe("System prompt for the agent"),
-  tools: z49.array(z49.string()).optional().describe("Tool keys (strings) to assign. Call list_tools first to see available keys. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array of tool names. Do NOT put middleware-like objects here \u2014 middleware goes in the separate 'middleware' field."),
-  middleware: z49.array(middlewareConfigSchema).optional().describe("Middleware configuration objects. Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here \u2014 tool names go in the separate 'tools' array. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
-  subAgents: z49.array(z49.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
-  internalSubAgents: z49.array(z49.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
-  modelKey: z49.string().optional().describe("Model key to use")
+var createAgentSchema = z50.object({
+  name: z50.string().describe("Human-friendly display name for the agent. The machine ID (used in other tools) is auto-generated as a slug from this name (e.g. 'My Cool Agent' \u2192 'my-cool-agent')."),
+  description: z50.string().optional().describe("Short description"),
+  type: z50.enum(["react", "deep_agent"]).describe("Agent type. Use 'react' for simple single-responsibility agents, 'deep_agent' for complex open-ended agents. For PROCESSING agents (workflow orchestration), use create_processing_agent instead."),
+  prompt: z50.string().describe("System prompt for the agent"),
+  tools: z50.array(z50.string()).optional().describe("Tool keys (strings) to assign. Call list_tools first to see available keys. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array of tool names. Do NOT put middleware-like objects here \u2014 middleware goes in the separate 'middleware' field."),
+  middleware: z50.array(middlewareConfigSchema).optional().describe("Middleware configuration objects. Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here \u2014 tool names go in the separate 'tools' array. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
+  subAgents: z50.array(z50.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
+  internalSubAgents: z50.array(z50.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
+  modelKey: z50.string().optional().describe("Model key to use")
 });
 registerToolLattice(
   "create_agent",
@@ -19102,14 +20067,14 @@ registerToolLattice(
     }
   }
 );
-var createWorkflowSchema = z49.object({
-  name: z49.string().describe("Display name for the workflow agent"),
-  description: z49.string().optional().describe("Short description"),
-  skillLoaded: z49.literal(true).describe("MUST be true. Set after loading the 'create-workflow' skill."),
-  yaml: z49.string().describe("The YAML workflow definition in linear DSL format (steps execute top-to-bottom, use parallel: for concurrency)"),
-  tools: z49.array(z49.string()).optional().describe("Tool keys for the workflow agent"),
-  middleware: z49.array(middlewareConfigSchema).optional().describe("Middleware configs"),
-  modelKey: z49.string().optional().describe("Model key")
+var createWorkflowSchema = z50.object({
+  name: z50.string().describe("Display name for the workflow agent"),
+  description: z50.string().optional().describe("Short description"),
+  skillLoaded: z50.literal(true).describe("MUST be true. Set after loading the 'create-workflow' skill."),
+  yaml: z50.string().describe("The YAML workflow definition in linear DSL format (steps execute top-to-bottom, use parallel: for concurrency)"),
+  tools: z50.array(z50.string()).optional().describe("Tool keys for the workflow agent"),
+  middleware: z50.array(middlewareConfigSchema).optional().describe("Middleware configs"),
+  modelKey: z50.string().optional().describe("Model key")
 });
 registerToolLattice(
   "create_workflow",
@@ -19158,8 +20123,8 @@ registerToolLattice(
   {
     name: "validate_workflow",
     description: "Validate a workflow agent's DSL for correctness by compiling it.",
-    schema: z49.object({
-      id: z49.string().describe("The workflow agent ID to validate")
+    schema: z50.object({
+      id: z50.string().describe("The workflow agent ID to validate")
     })
   },
   async (input, exeConfig) => {
@@ -19256,14 +20221,14 @@ registerToolLattice(
     }
   }
 );
-var updateWorkflowSchema = z49.object({
-  id: z49.string().describe("The workflow agent ID to update"),
-  name: z49.string().optional().describe("New display name"),
-  description: z49.string().optional().describe("New description"),
-  yaml: z49.string().optional().describe("Replacement YAML workflow DSL. Omit to keep existing."),
-  tools: z49.array(z49.string()).optional().describe("Replacement tool keys"),
-  middleware: z49.array(middlewareConfigSchema).optional().describe("Replacement middleware configs"),
-  modelKey: z49.string().optional().describe("Replacement model key")
+var updateWorkflowSchema = z50.object({
+  id: z50.string().describe("The workflow agent ID to update"),
+  name: z50.string().optional().describe("New display name"),
+  description: z50.string().optional().describe("New description"),
+  yaml: z50.string().optional().describe("Replacement YAML workflow DSL. Omit to keep existing."),
+  tools: z50.array(z50.string()).optional().describe("Replacement tool keys"),
+  middleware: z50.array(middlewareConfigSchema).optional().describe("Replacement middleware configs"),
+  modelKey: z50.string().optional().describe("Replacement model key")
 });
 registerToolLattice(
   "update_workflow",
@@ -19324,18 +20289,18 @@ registerToolLattice(
     }
   }
 );
-var updateAgentSchema = z49.object({
-  id: z49.string().describe("The agent ID to update"),
-  config: z49.object({
-    name: z49.string().optional().describe("New display name for the agent"),
-    description: z49.string().optional().describe("New short description"),
-    type: z49.enum(["react", "deep_agent"]).optional().describe("Agent type"),
-    prompt: z49.string().optional().describe("New system prompt for the agent"),
-    tools: z49.array(z49.string()).optional().describe("Tool keys to assign to this agent. These are registered tool names (strings), NOT middleware objects."),
-    middleware: z49.array(middlewareConfigSchema).optional().describe("Middleware configurations. NOTE: middleware objects have type/name/description/enabled/config fields and are NOT the same as tools. Tool keys go in the 'tools' array. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
-    subAgents: z49.array(z49.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
-    internalSubAgents: z49.array(z49.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
-    modelKey: z49.string().optional().describe("Model key to use")
+var updateAgentSchema = z50.object({
+  id: z50.string().describe("The agent ID to update"),
+  config: z50.object({
+    name: z50.string().optional().describe("New display name for the agent"),
+    description: z50.string().optional().describe("New short description"),
+    type: z50.enum(["react", "deep_agent"]).optional().describe("Agent type"),
+    prompt: z50.string().optional().describe("New system prompt for the agent"),
+    tools: z50.array(z50.string()).optional().describe("Tool keys to assign to this agent. These are registered tool names (strings), NOT middleware objects."),
+    middleware: z50.array(middlewareConfigSchema).optional().describe("Middleware configurations. NOTE: middleware objects have type/name/description/enabled/config fields and are NOT the same as tools. Tool keys go in the 'tools' array. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
+    subAgents: z50.array(z50.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
+    internalSubAgents: z50.array(z50.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
+    modelKey: z50.string().optional().describe("Model key to use")
   }).describe("Configuration fields to update. Only include the fields you want to change.")
 });
 registerToolLattice(
@@ -19373,8 +20338,8 @@ registerToolLattice(
   {
     name: "delete_agent",
     description: "Permanently delete an agent by its ID. This action cannot be undone.",
-    schema: z49.object({
-      id: z49.string().describe("The agent ID to delete")
+    schema: z50.object({
+      id: z50.string().describe("The agent ID to delete")
     })
   },
   async (input, exeConfig) => {
@@ -19400,7 +20365,7 @@ registerToolLattice(
   {
     name: "list_tools",
     description: "List all available tools that can be assigned to agents. Returns each tool's name (use this string value in the 'tools' array), description, and whether it requires user approval. The tool names from this list are what you pass as strings in the 'tools' field of create_agent or update_agent.",
-    schema: z49.object({})
+    schema: z50.object({})
   },
   async (_input, _exeConfig) => {
     try {
@@ -19422,9 +20387,9 @@ registerToolLattice(
   {
     name: "invoke_agent",
     description: "Invoke an agent with a test message and return its response. Use this to verify an agent works correctly after creating or modifying it. The agent must be compiled (already created and valid).",
-    schema: z49.object({
-      id: z49.string().describe("The agent ID to invoke"),
-      message: z49.string().describe("The test message to send to the agent")
+    schema: z50.object({
+      id: z50.string().describe("The agent ID to invoke"),
+      message: z50.string().describe("The test message to send to the agent")
     })
   },
   async (input, exeConfig) => {
@@ -19439,7 +20404,7 @@ registerToolLattice(
       if (!existing) {
         return JSON.stringify({ error: `Agent '${id}' not found` });
       }
-      const threadId = v43();
+      const threadId = v44();
       const agent = new Agent({
         tenant_id: tenantId2,
         assistant_id: id,
@@ -19460,7 +20425,7 @@ registerToolLattice(
   {
     name: "list_middleware_types",
     description: "\u5217\u51FA\u5F53\u524D\u7CFB\u7EDF\u4E2D\u6240\u6709\u53EF\u7528\u7684\u4E2D\u95F4\u4EF6\u7C7B\u578B\uFF08Middlewares\uFF09\uFF0C\u5305\u62EC\u5185\u7F6E\u548C\u81EA\u5B9A\u4E49\u63D2\u4EF6\u3002\u8FD4\u56DE\u6BCF\u4E2A\u4E2D\u95F4\u4EF6\u7684 type\u3001name\u3001description\u3001tools \u6E05\u5355\uFF08\u652F\u6301 allowedTools \u8FC7\u6EE4\uFF09\u3001configSchema\uFF08\u914D\u7F6E\u9762\u677F\u9700\u8981\u54EA\u4E9B\u5B57\u6BB5\uFF09\u548C connectionSchema\uFF08\u662F\u5426\u652F\u6301\u8FDE\u63A5\u6D4B\u8BD5\u548C\u8D44\u6E90\u53D1\u73B0\uFF09\u3002\n\n\u4F7F\u7528\u573A\u666F\uFF1A\n1. \u5728\u521B\u5EFA agent \u524D\uFF0C\u5148\u8C03\u6B64\u5DE5\u5177\u4E86\u89E3\u6709\u54EA\u4E9B\u4E2D\u95F4\u4EF6\u53EF\u914D\u7F6E\n2. \u6839\u636E configSchema \u51B3\u5B9A\u9700\u8981\u63D0\u4F9B\u54EA\u4E9B\u914D\u7F6E\u5B57\u6BB5\uFF08\u5982 databaseKeys\u3001connections \u7B49\uFF09\n3. \u5982\u679C\u67D0\u4E2A\u4E2D\u95F4\u4EF6\u7684 connectionSchema \u5B58\u5728\uFF0C\u8BF4\u660E\u5B83\u662F\u8FDE\u63A5\u578B\u4E2D\u95F4\u4EF6\uFF0C\u9700\u8981\u518D\u8C03 list_connections \u83B7\u53D6\u53EF\u7528\u8FDE\u63A5\n4. \u7528\u8FD4\u56DE\u7684 type \u5B57\u6BB5\u6784\u5EFA middleware \u6570\u7EC4\u4F20\u7ED9 create_agent / update_agent",
-    schema: z49.object({})
+    schema: z50.object({})
   },
   async () => {
     const metas = PluginRegistry.listMeta();
@@ -19472,8 +20437,8 @@ registerToolLattice(
   {
     name: "list_connections",
     description: "\u5217\u51FA\u6307\u5B9A\u63D2\u4EF6\u7C7B\u578B\u7684\u6240\u6709\u5DF2\u914D\u7F6E\u8FDE\u63A5\u3002\u7528\u4E8E\u67E5\u8BE2\u6709\u54EA\u4E9B\u53EF\u7528\u7684\u8FDE\u63A5\u5B9E\u4F8B\uFF08\u5982 'sap-prod', 'sap-dev'\uFF09\uFF0C\u65B9\u4FBF\u5728 agent \u914D\u7F6E\u4E2D\u9009\u62E9\u5177\u4F53\u8FDE\u63A5\u3002\n\n\u4F7F\u7528\u573A\u666F\uFF1A\n1. \u5148\u8C03 list_middleware_types \u786E\u5B9A\u67D0\u4E2A\u4E2D\u95F4\u4EF6\u662F\u8FDE\u63A5\u578B\uFF08\u6709 connectionSchema\uFF09\n2. \u8C03\u6B64\u5DE5\u5177\u4F20\u5165 type\uFF08\u5982 'erp'\uFF09\uFF0C\u83B7\u53D6\u8BE5\u7C7B\u578B\u4E0B\u5DF2\u914D\u597D\u7684\u8FDE\u63A5\u5217\u8868\n3. \u5728 create_agent \u7684 middleware[i].config.connections \u4E2D\u586B\u5165\u5BF9\u5E94\u7684 key \u503C\n\n\u8FD4\u56DE\u683C\u5F0F\uFF1A{ success: true, data: { records: [{ key, name, ... }] } }",
-    schema: z49.object({
-      type: z49.string().describe("\u63D2\u4EF6\u7C7B\u578B\u6807\u8BC6\uFF0C\u5982 'erp'\u3002\u4ECE list_middleware_types \u7684\u8FD4\u56DE\u4E2D\u83B7\u53D6")
+    schema: z50.object({
+      type: z50.string().describe("\u63D2\u4EF6\u7C7B\u578B\u6807\u8BC6\uFF0C\u5982 'erp'\u3002\u4ECE list_middleware_types \u7684\u8FD4\u56DE\u4E2D\u83B7\u53D6")
     }),
     needUserApprove: false
   },
@@ -20054,6 +21019,20 @@ function ensureBuiltinAgentsForTenant(tenantId2) {
   }
 }
 
+// src/agent_lattice/pluginAgents.ts
+function ensurePluginAgentsForTenant(tenantId2) {
+  const pluginTypes = PluginRegistry.list();
+  for (const pluginType of pluginTypes) {
+    const plugin = PluginRegistry.get(pluginType);
+    if (!plugin?.agents) continue;
+    for (const [key4, config] of Object.entries(plugin.agents)) {
+      if (!agentLatticeManager.hasWithTenant(tenantId2, key4)) {
+        agentLatticeManager.registerLatticeWithTenant(tenantId2, config);
+      }
+    }
+  }
+}
+
 // src/agent_lattice/AgentLatticeManager.ts
 function assistantToConfig(assistant) {
   const graphDef = typeof assistant.graphDefinition === "object" && assistant.graphDefinition !== null ? { ...assistant.graphDefinition } : {};
@@ -20252,6 +21231,7 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
    */
   async initializeStoredAssistantsForTenant(tenantId2) {
     ensureBuiltinAgentsForTenant(tenantId2);
+    ensurePluginAgentsForTenant(tenantId2);
     try {
       const storeLattice = getStoreLattice("default", "assistant");
       const assistants = await storeLattice.store.getAllAssistants(tenantId2);
@@ -23426,8 +24406,8 @@ function clearEvalRunService() {
 }
 
 // src/eval_lattice/LatticeEval.ts
-import { HumanMessage as HumanMessage3 } from "@langchain/core/messages";
-import { v4 as v44 } from "uuid";
+import { HumanMessage as HumanMessage4 } from "@langchain/core/messages";
+import { v4 as v45 } from "uuid";
 var _LatticeEval = class _LatticeEval {
   constructor(config = {}) {
     this.inMemoryLogs = [];
@@ -23567,7 +24547,7 @@ var _LatticeEval = class _LatticeEval {
   }
   async evaluateCase(evalCase) {
     const startedAt = Date.now();
-    const threadId = `${evalCase.caseId}||${v44()}`;
+    const threadId = `${evalCase.caseId}||${v45()}`;
     this.inMemoryLogs = [];
     this.lastThreadId = threadId;
     this.lastJudgeThreadId = void 0;
@@ -23709,7 +24689,7 @@ ${rubricsSection}
 
 \u6CE8\u610F\uFF1A\u5982\u679C final_score >= 80 \u4E14\u6CA1\u6709\u81F4\u547D\u6027\u9519\u8BEF\uFF0Cpass \u5E94\u4E3A true\uFF1B\u5426\u5219\u4E3A false\u3002`;
     this.lastTestPrompt = testPrompt;
-    const judgeThreadId = v44();
+    const judgeThreadId = v45();
     this.lastJudgeThreadId = judgeThreadId;
     const judgeAgentKey = this.config.judge_agent_key || "LatticeTest";
     const judgeTenantId = this.config.tenant_id || "default";
@@ -23717,7 +24697,7 @@ ${rubricsSection}
     const judgeAgent = await getAgentClient(judgeTenantId, judgeAgentKey);
     const testResponse = await judgeAgent.invoke(
       {
-        messages: [new HumanMessage3(testPrompt)]
+        messages: [new HumanMessage4(testPrompt)]
       },
       {
         configurable: {
@@ -24309,15 +25289,15 @@ function clearEncryptionKeyCache() {
 }
 
 // src/middlewares/skillMiddleware.ts
-import { createMiddleware as createMiddleware15 } from "langchain";
+import { createMiddleware as createMiddleware16 } from "langchain";
 
 // src/tool_lattice/skill/load_skills.ts
-import z50 from "zod";
-import { tool as tool45 } from "langchain";
-
-// src/tool_lattice/skill/load_skill_content.ts
 import z51 from "zod";
 import { tool as tool46 } from "langchain";
+
+// src/tool_lattice/skill/load_skill_content.ts
+import z52 from "zod";
+import { tool as tool47 } from "langchain";
 var LOAD_SKILL_CONTENT_DESCRIPTION = `
 Execute a skill within the main conversation
 
@@ -24355,7 +25335,7 @@ function getSandboxFromExeConfig(_exe_config) {
   });
 }
 var createLoadSkillContentTool = (pluginSkillContents) => {
-  return tool46(
+  return tool47(
     async (input, _exe_config) => {
       try {
         if (pluginSkillContents?.[input.skill_name]) {
@@ -24404,8 +25384,8 @@ var createLoadSkillContentTool = (pluginSkillContents) => {
     {
       name: "skill",
       description: LOAD_SKILL_CONTENT_DESCRIPTION,
-      schema: z51.object({
-        skill_name: z51.string().describe("The name of the skill to load")
+      schema: z52.object({
+        skill_name: z52.string().describe("The name of the skill to load")
       })
     }
   );
@@ -24419,7 +25399,7 @@ function createSkillMiddleware(params = {}) {
   } = params;
   const skills = params.skills;
   let latestSkills = [];
-  return createMiddleware15({
+  return createMiddleware16({
     name: "skillMiddleware",
     contextSchema,
     tools: [
@@ -24551,17 +25531,17 @@ var skillPlugin = {
 };
 
 // src/middlewares/collectionMiddleware.ts
-import { createMiddleware as createMiddleware16 } from "langchain";
+import { createMiddleware as createMiddleware17 } from "langchain";
 
 // src/tool_lattice/collection/list_collections.ts
-import z52 from "zod";
-import { tool as tool47 } from "langchain";
+import z53 from "zod";
+import { tool as tool48 } from "langchain";
 var LIST_COLLECTIONS_DESCRIPTION = `List all available collections for the current tenant. Returns collection names, labels, and field definitions (including field types and enum values). Use this tool to discover what collections are available before searching.`;
 var createListCollectionsTool = ({
   collectionKeys,
   connectAll
 }) => {
-  return tool47(
+  return tool48(
     async (_input, _exeConfig) => {
       try {
         const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -24595,23 +25575,23 @@ var createListCollectionsTool = ({
     {
       name: "list_collections",
       description: LIST_COLLECTIONS_DESCRIPTION,
-      schema: z52.object({})
+      schema: z53.object({})
     }
   );
 };
 
 // src/tool_lattice/collection/search_collection.ts
-import z53 from "zod";
-import { tool as tool48 } from "langchain";
+import z54 from "zod";
+import { tool as tool49 } from "langchain";
 var SEARCH_COLLECTION_DESCRIPTION = `Search for content within a specific collection using semantic (vector) similarity. Use the 'filter' parameter to narrow results by metadata fields (e.g., {"category": "cardiovascular"}). Returns the most relevant content entries with similarity scores.`;
-var searchSchema = z53.object({
-  collection: z53.string().describe("The collection name to search in"),
-  query: z53.string().describe("The search query text"),
-  filter: z53.record(z53.unknown()).optional().describe("Metadata filter conditions"),
-  top_k: z53.number().optional().default(5).describe("Number of results to return")
+var searchSchema = z54.object({
+  collection: z54.string().describe("The collection name to search in"),
+  query: z54.string().describe("The search query text"),
+  filter: z54.record(z54.unknown()).optional().describe("Metadata filter conditions"),
+  top_k: z54.number().optional().default(5).describe("Number of results to return")
 });
 var createSearchCollectionTool = () => {
-  return tool48(
+  return tool49(
     async (input, _exeConfig) => {
       try {
         const { collection, query, filter: filter2, top_k } = input;
@@ -24661,10 +25641,10 @@ var createSearchCollectionTool = () => {
 };
 
 // src/tool_lattice/collection/get_collection.ts
-import z54 from "zod";
-import { tool as tool49 } from "langchain";
+import z55 from "zod";
+import { tool as tool50 } from "langchain";
 var GET_COLLECTION_DESCRIPTION = `Get a collection's full definition including its custom fields schema. Use this to discover what metadata fields are available before adding entries.`;
-var createGetCollectionTool = () => tool49(
+var createGetCollectionTool = () => tool50(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -24687,24 +25667,24 @@ Embedding: ${c.embeddingKey}${fieldsDesc}`;
       return `Error: ${error.message}`;
     }
   },
-  { name: "get_collection", description: GET_COLLECTION_DESCRIPTION, schema: z54.object({ name: z54.string().describe("Collection name") }) }
+  { name: "get_collection", description: GET_COLLECTION_DESCRIPTION, schema: z55.object({ name: z55.string().describe("Collection name") }) }
 );
 
 // src/tool_lattice/collection/create_collection.ts
-import z55 from "zod";
-import { tool as tool50 } from "langchain";
-var createSchema = z55.object({
-  name: z55.string().describe("Collection name (lowercase, underscores only)"),
-  label: z55.string().describe("Display name"),
-  embeddingKey: z55.string().describe("Embedding model key"),
-  fields: z55.array(z55.object({
-    key: z55.string().describe("Field key name"),
-    type: z55.enum(["string", "number", "enum"]).describe("Field data type"),
-    enumValues: z55.array(z55.string()).optional().describe("Valid values for enum type"),
-    required: z55.boolean().optional().default(false).describe("Whether field is required")
+import z56 from "zod";
+import { tool as tool51 } from "langchain";
+var createSchema = z56.object({
+  name: z56.string().describe("Collection name (lowercase, underscores only)"),
+  label: z56.string().describe("Display name"),
+  embeddingKey: z56.string().describe("Embedding model key"),
+  fields: z56.array(z56.object({
+    key: z56.string().describe("Field key name"),
+    type: z56.enum(["string", "number", "enum"]).describe("Field data type"),
+    enumValues: z56.array(z56.string()).optional().describe("Valid values for enum type"),
+    required: z56.boolean().optional().default(false).describe("Whether field is required")
   })).optional().describe("Custom field definitions for entries in this collection")
 });
-var createCreateCollectionTool = () => tool50(
+var createCreateCollectionTool = () => tool51(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -24729,20 +25709,20 @@ var createCreateCollectionTool = () => tool50(
 );
 
 // src/tool_lattice/collection/update_collection.ts
-import z56 from "zod";
-import { tool as tool51 } from "langchain";
-var schema = z56.object({
-  name: z56.string().describe("Collection name"),
-  label: z56.string().optional().describe("New display name"),
-  embeddingKey: z56.string().optional().describe("New embedding model key"),
-  fields: z56.array(z56.object({
-    key: z56.string().describe("Field key name"),
-    type: z56.enum(["string", "number", "enum"]).describe("Field data type"),
-    enumValues: z56.array(z56.string()).optional().describe("Valid values for enum type"),
-    required: z56.boolean().optional().default(false).describe("Whether field is required")
+import z57 from "zod";
+import { tool as tool52 } from "langchain";
+var schema = z57.object({
+  name: z57.string().describe("Collection name"),
+  label: z57.string().optional().describe("New display name"),
+  embeddingKey: z57.string().optional().describe("New embedding model key"),
+  fields: z57.array(z57.object({
+    key: z57.string().describe("Field key name"),
+    type: z57.enum(["string", "number", "enum"]).describe("Field data type"),
+    enumValues: z57.array(z57.string()).optional().describe("Valid values for enum type"),
+    required: z57.boolean().optional().default(false).describe("Whether field is required")
   })).optional().describe("Custom field definitions for entries (replaces existing schema)")
 });
-var createUpdateCollectionTool = () => tool51(
+var createUpdateCollectionTool = () => tool52(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -24761,9 +25741,9 @@ var createUpdateCollectionTool = () => tool51(
 );
 
 // src/tool_lattice/collection/delete_collection.ts
-import z57 from "zod";
-import { tool as tool52 } from "langchain";
-var createDeleteCollectionTool = () => tool52(
+import z58 from "zod";
+import { tool as tool53 } from "langchain";
+var createDeleteCollectionTool = () => tool53(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -24773,19 +25753,19 @@ var createDeleteCollectionTool = () => tool52(
       return `Error: ${e.message}`;
     }
   },
-  { name: "delete_collection", description: `Delete a collection and all its entries. This cannot be undone.`, schema: z57.object({ name: z57.string().describe("Collection name") }) }
+  { name: "delete_collection", description: `Delete a collection and all its entries. This cannot be undone.`, schema: z58.object({ name: z58.string().describe("Collection name") }) }
 );
 
 // src/tool_lattice/collection/list_entries.ts
-import z58 from "zod";
-import { tool as tool53 } from "langchain";
-var schema2 = z58.object({
-  collection: z58.string().describe("Collection name")
+import z59 from "zod";
+import { tool as tool54 } from "langchain";
+var schema2 = z59.object({
+  collection: z59.string().describe("Collection name")
 });
 function buildKey2(tenantId2, name) {
   return `${tenantId2}:${name}`;
 }
-var createListEntriesTool = () => tool53(
+var createListEntriesTool = () => tool54(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -24812,19 +25792,19 @@ var createListEntriesTool = () => tool53(
 );
 
 // src/tool_lattice/collection/add_entry.ts
-import z59 from "zod";
-import { tool as tool54 } from "langchain";
+import z60 from "zod";
+import { tool as tool55 } from "langchain";
 import { Document } from "@langchain/core/documents";
 import { v4 as uuidv45 } from "uuid";
-var schema3 = z59.object({
-  collection: z59.string().describe("Collection name"),
-  content: z59.string().describe("Entry content text"),
-  metadata: z59.record(z59.unknown()).optional().describe("Metadata fields matching the collection schema")
+var schema3 = z60.object({
+  collection: z60.string().describe("Collection name"),
+  content: z60.string().describe("Entry content text"),
+  metadata: z60.record(z60.unknown()).optional().describe("Metadata fields matching the collection schema")
 });
 function key(t, n) {
   return `${t}:${n}`;
 }
-var createAddEntryTool = () => tool54(
+var createAddEntryTool = () => tool55(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -24843,18 +25823,18 @@ var createAddEntryTool = () => tool54(
 );
 
 // src/tool_lattice/collection/update_entry.ts
-import z60 from "zod";
-import { tool as tool55 } from "langchain";
-var schema4 = z60.object({
-  collection: z60.string().describe("Collection name"),
-  entryId: z60.string().describe("Entry ID to update"),
-  content: z60.string().optional().describe("New content"),
-  metadata: z60.record(z60.unknown()).optional().describe("New metadata")
+import z61 from "zod";
+import { tool as tool56 } from "langchain";
+var schema4 = z61.object({
+  collection: z61.string().describe("Collection name"),
+  entryId: z61.string().describe("Entry ID to update"),
+  content: z61.string().optional().describe("New content"),
+  metadata: z61.record(z61.unknown()).optional().describe("New metadata")
 });
 function key2(t, n) {
   return `${t}:${n}`;
 }
-var createUpdateEntryTool = () => tool55(
+var createUpdateEntryTool = () => tool56(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -24873,16 +25853,16 @@ var createUpdateEntryTool = () => tool55(
 );
 
 // src/tool_lattice/collection/delete_entry.ts
-import z61 from "zod";
-import { tool as tool56 } from "langchain";
-var schema5 = z61.object({
-  collection: z61.string().describe("Collection name"),
-  entryId: z61.string().describe("Entry ID to delete")
+import z62 from "zod";
+import { tool as tool57 } from "langchain";
+var schema5 = z62.object({
+  collection: z62.string().describe("Collection name"),
+  entryId: z62.string().describe("Entry ID to delete")
 });
 function key3(t, n) {
   return `${t}:${n}`;
 }
-var createDeleteEntryTool = () => tool56(
+var createDeleteEntryTool = () => tool57(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -24900,7 +25880,7 @@ var createDeleteEntryTool = () => tool56(
 function createCollectionMiddleware(params) {
   const { collectionKeys, connectAll } = params;
   if (!connectAll && (!collectionKeys || collectionKeys.length === 0)) {
-    return createMiddleware16({
+    return createMiddleware17({
       name: "collectionMiddleware",
       contextSchema,
       tools: [
@@ -24910,7 +25890,7 @@ function createCollectionMiddleware(params) {
     });
   }
   const listToolParams = { collectionKeys, connectAll };
-  return createMiddleware16({
+  return createMiddleware17({
     name: "collectionMiddleware",
     contextSchema,
     tools: [
@@ -24971,24 +25951,24 @@ var collectionPlugin = {
 };
 
 // src/middlewares/askUserClarifyMiddleware.ts
-import { createMiddleware as createMiddleware17, ToolMessage as ToolMessage8 } from "langchain";
+import { createMiddleware as createMiddleware18, ToolMessage as ToolMessage8 } from "langchain";
 import { GraphInterrupt as GraphInterrupt3, interrupt as interrupt3 } from "@langchain/langgraph";
 
 // src/tool_lattice/ask_user_to_clarify/index.ts
-import { tool as tool57 } from "langchain";
-import z62 from "zod";
-var questionSchema = z62.object({
-  question: z62.string().describe("The question text to ask the user"),
-  options: z62.array(z62.string()).optional().default([]).describe("List of EXACT, selectable values. Maximum 3 options allowed. DO NOT include placeholder values like 'Other' or 'Enter manually'. For free-text with predefined choices, use allowOther=true (works with 'single' and 'multiple'). For pure free-text without choices, use type='input' instead. For file_upload and input, pass an empty array."),
-  type: z62.enum(["single", "multiple", "file_upload", "input"]).describe("The question format. 'single' = pick one from options (default, see tool description for guidance). 'multiple' = pick several from options. 'input' = free-text field (only when options cannot express the answer). 'file_upload' = file picker."),
-  required: z62.boolean().optional().default(false).describe("Whether this question must be answered"),
-  allowOther: z62.boolean().optional().default(true).describe("Set to true to append an 'Other' checkbox with a free-text input field. Works with 'single' and 'multiple' types. Use for open-ended answers or when the options cannot cover all possibilities. Not applicable for 'input' or 'file_upload' types.")
+import { tool as tool58 } from "langchain";
+import z63 from "zod";
+var questionSchema = z63.object({
+  question: z63.string().describe("The question text to ask the user"),
+  options: z63.array(z63.string()).optional().default([]).describe("List of EXACT, selectable values. Maximum 3 options allowed. DO NOT include placeholder values like 'Other' or 'Enter manually'. For free-text with predefined choices, use allowOther=true (works with 'single' and 'multiple'). For pure free-text without choices, use type='input' instead. For file_upload and input, pass an empty array."),
+  type: z63.enum(["single", "multiple", "file_upload", "input"]).describe("The question format. 'single' = pick one from options (default, see tool description for guidance). 'multiple' = pick several from options. 'input' = free-text field (only when options cannot express the answer). 'file_upload' = file picker."),
+  required: z63.boolean().optional().default(false).describe("Whether this question must be answered"),
+  allowOther: z63.boolean().optional().default(true).describe("Set to true to append an 'Other' checkbox with a free-text input field. Works with 'single' and 'multiple' types. Use for open-ended answers or when the options cannot cover all possibilities. Not applicable for 'input' or 'file_upload' types.")
 });
-var inputSchema = z62.object({
-  questions: z62.array(questionSchema).min(1, "At least one question is required").describe("A structured sequence of clarification questions. Use these to gather missing parameters or disambiguate user intent before proceeding.")
+var inputSchema = z63.object({
+  questions: z63.array(questionSchema).min(1, "At least one question is required").describe("A structured sequence of clarification questions. Use these to gather missing parameters or disambiguate user intent before proceeding.")
 });
 function createAskUserToClarifyTool() {
-  return tool57(
+  return tool58(
     async (input) => {
       return JSON.stringify(input);
     },
@@ -25002,7 +25982,7 @@ function createAskUserToClarifyTool() {
 
 // src/middlewares/askUserClarifyMiddleware.ts
 function createAskUserClarifyMiddleware() {
-  return createMiddleware17({
+  return createMiddleware18({
     name: "AskUserClarifyMiddleware",
     tools: [createAskUserToClarifyTool()],
     wrapToolCall: async (request, handler) => {
@@ -25110,11 +26090,11 @@ var askUserClarifyPlugin = {
 };
 
 // src/middlewares/widgetMiddleware.ts
-import { createMiddleware as createMiddleware18 } from "langchain";
+import { createMiddleware as createMiddleware19 } from "langchain";
 
 // src/tool_lattice/widget/loadGuidelines.ts
-import { tool as tool58 } from "langchain";
-import { z as z63 } from "zod";
+import { tool as tool59 } from "langchain";
+import { z as z64 } from "zod";
 
 // src/middlewares/guidelines/index.ts
 var CORE = `# Imagine \u2014 Visual Creation Suite
@@ -25905,13 +26885,13 @@ function getGuidelines(modules) {
 var AVAILABLE_MODULES = Object.keys(MODULE_SECTIONS);
 
 // src/tool_lattice/widget/loadGuidelines.ts
-var LoadGuidelinesInputSchema = z63.object({
-  modules: z63.array(z63.string()).describe(
+var LoadGuidelinesInputSchema = z64.object({
+  modules: z64.array(z64.string()).describe(
     "Which design modules to load. Choose all that apply. Available modules: [" + AVAILABLE_MODULES.join(",") + "]"
   )
 });
 function createLoadGuidelinesTool() {
-  return tool58(
+  return tool59(
     async (input) => {
       const result = getGuidelines(input.modules);
       return result;
@@ -25925,8 +26905,8 @@ function createLoadGuidelinesTool() {
 }
 
 // src/tool_lattice/widget/showWidget.ts
-import { tool as tool59 } from "langchain";
-import { z as z64 } from "zod";
+import { tool as tool60 } from "langchain";
+import { z as z65 } from "zod";
 function containsForbiddenTags(code) {
   const forbiddenPatterns = [
     /<!DOCTYPE/i,
@@ -25948,20 +26928,20 @@ function validateWidgetCode(code) {
   }
   return { valid: true };
 }
-var ShowWidgetInputSchema = z64.object({
-  i_have_seen_guidelines: z64.boolean().describe(
+var ShowWidgetInputSchema = z65.object({
+  i_have_seen_guidelines: z65.boolean().describe(
     "Must be true. Confirm you have called load_guidelines first."
   ),
-  title: z64.string().describe("Title displayed above the widget"),
-  loading_messages: z64.array(z64.string()).optional().describe(
+  title: z65.string().describe("Title displayed above the widget"),
+  loading_messages: z65.array(z65.string()).optional().describe(
     "1-4 short strings shown while the widget renders"
   ),
-  widget_code: z64.string().describe(
+  widget_code: z65.string().describe(
     "HTML fragment to render. Rules: 1. No DOCTYPE, <html>, <head>, or <body> tags. 2. Order: <style> block first, then HTML content, then <script> last. 3. Use only CSS variables for colors (e.g. var(--color-accent)). 4. No gradients, shadows, or blur effects. For SVG: start directly with <svg> tag."
   )
 });
 function createShowWidgetTool() {
-  return tool59(
+  return tool60(
     async (input) => {
       if (!input.i_have_seen_guidelines) {
         return "Error: You must call load_guidelines before using show_widget. Set i_have_seen_guidelines to true only after loading guidelines.";
@@ -25992,7 +26972,7 @@ function createWidgetMiddleware() {
     createLoadGuidelinesTool(),
     createShowWidgetTool()
   ];
-  return createMiddleware18({
+  return createMiddleware19({
     name: "widgetMiddleware",
     contextSchema,
     tools
@@ -26014,153 +26994,6 @@ var widgetPlugin = {
   middleware: () => createWidgetMiddleware()
 };
 
-// src/middlewares/taskMiddleware.ts
-import { createMiddleware as createMiddleware19, tool as tool60 } from "langchain";
-import { z as z65 } from "zod";
-function getRunConfig2(config) {
-  const c = config;
-  return c?.configurable?.runConfig ?? {};
-}
-function getTaskStore() {
-  return getStoreLattice("default", "task").store;
-}
-var manageTaskSchema = z65.object({
-  action: z65.enum(["create", "list", "update", "delete", "complete"]).describe("\u64CD\u4F5C\u7C7B\u578B"),
-  id: z65.string().optional().describe("\u4EFB\u52A1 ID (update/delete/complete \u5FC5\u586B)"),
-  title: z65.string().optional().describe("\u4EFB\u52A1\u6807\u9898 (create \u5FC5\u586B)"),
-  description: z65.string().optional().describe("\u4EFB\u52A1\u63CF\u8FF0"),
-  priority: z65.enum(["low", "medium", "high"]).optional().describe("\u4F18\u5148\u7EA7"),
-  status: z65.enum(["pending", "in_progress", "completed", "cancelled"]).optional().describe("\u72B6\u6001"),
-  dueDate: z65.string().optional().describe("\u622A\u6B62\u65E5\u671F (ISO 8601)"),
-  metadata: z65.record(z65.unknown()).optional().describe("\u7ED3\u6784\u5316\u5143\u6570\u636E (projectId, module \u7B49)"),
-  parentId: z65.string().optional().describe("\u7236\u4EFB\u52A1 ID (\u5B50\u4EFB\u52A1\u5173\u8054)"),
-  sourceId: z65.string().optional().describe("\u6765\u6E90\u4F1A\u8BDD/thread ID"),
-  context: z65.record(z65.unknown()).optional().describe("\u9644\u52A0\u4E0A\u4E0B\u6587"),
-  ownerType: z65.enum(["user", "agent"]).optional().describe("\u6240\u6709\u8005\u7C7B\u578B\uFF0C\u4E0D\u4F20\u9ED8\u8BA4\u4E3A user"),
-  ownerId: z65.string().optional().describe("\u6240\u6709\u8005 ID\uFF0C\u4E0D\u4F20\u81EA\u52A8\u53D6\u5F53\u524D\u7528\u6237/Agent")
-});
-function createTaskMiddleware() {
-  return createMiddleware19({
-    name: "TaskMiddleware",
-    contextSchema,
-    wrapModelCall: async (request, handler) => {
-      const taskPrompt = `## \u4EFB\u52A1\u7BA1\u7406\u80FD\u529B
-\u4F60\u53EF\u4EE5\u901A\u8FC7 manage_task \u5DE5\u5177\u7BA1\u7406\u6301\u4E45\u5316\u4EFB\u52A1\u3002ownerType \u548C ownerId \u7684\u9ED8\u8BA4\u884C\u4E3A\uFF1A
-- \u4E0D\u4F20\u53C2\u6570: \u9ED8\u8BA4\u4E3A\u5F53\u524D\u7528\u6237\u521B\u5EFA\u4EFB\u52A1 (ownerType="user", ownerId \u81EA\u52A8\u53D6\u5F53\u524D\u7528\u6237)
-- ownerType="agent": \u4E3A\u81EA\u5DF1\u521B\u5EFA\u6267\u884C\u5B50\u4EFB\u52A1 (ownerId \u81EA\u52A8\u53D6\u5F53\u524D Agent)
-- \u663E\u5F0F\u4F20 ownerId: \u4E3A\u6307\u5B9A agent/user \u521B\u5EFA\u4EFB\u52A1\uFF08\u62D3\u6251\u573A\u666F\uFF09`;
-      return handler({
-        ...request,
-        systemPrompt: taskPrompt + "\n\n" + (request.systemPrompt ?? "")
-      });
-    },
-    tools: [
-      tool60(
-        async (input, config) => {
-          const rc = getRunConfig2(config);
-          const tenantId2 = rc.tenantId || "default";
-          const ownerId = input.ownerId || (input.ownerType === "agent" ? rc.assistant_id : null) || rc.user_id;
-          const store = getTaskStore();
-          switch (input.action) {
-            case "create": {
-              if (!input.title) {
-                return JSON.stringify({ success: false, error: "create requires title" });
-              }
-              const task = await store.create({
-                tenantId: tenantId2,
-                ownerType: input.ownerType || "user",
-                ownerId,
-                title: input.title,
-                description: input.description,
-                priority: input.priority || "medium",
-                status: input.status || "pending",
-                dueDate: input.dueDate,
-                metadata: input.metadata,
-                parentId: input.parentId,
-                sourceId: input.sourceId,
-                context: input.context
-              });
-              return JSON.stringify({ success: true, data: task });
-            }
-            case "list": {
-              const tasks = await store.list({
-                tenantId: tenantId2,
-                ownerType: input.ownerType,
-                ownerId: input.ownerId,
-                status: input.status,
-                priority: input.priority
-              });
-              return JSON.stringify({ success: true, data: tasks, count: tasks.length });
-            }
-            case "update": {
-              if (!input.id) {
-                return JSON.stringify({ success: false, error: "update requires id" });
-              }
-              const { action, ...updates } = input;
-              const updated = await store.update(tenantId2, input.id, updates);
-              if (!updated) {
-                return JSON.stringify({ success: false, error: "Task not found" });
-              }
-              return JSON.stringify({ success: true, data: updated });
-            }
-            case "delete": {
-              if (!input.id) {
-                return JSON.stringify({ success: false, error: "delete requires id" });
-              }
-              const deleted = await store.delete(tenantId2, input.id);
-              return JSON.stringify({ success: deleted, message: deleted ? "Task deleted" : "Task not found" });
-            }
-            case "complete": {
-              if (!input.id) {
-                return JSON.stringify({ success: false, error: "complete requires id" });
-              }
-              const updated = await store.update(tenantId2, input.id, { status: "completed" });
-              if (!updated) {
-                return JSON.stringify({ success: false, error: "Task not found" });
-              }
-              return JSON.stringify({ success: true, data: updated });
-            }
-            default:
-              return JSON.stringify({ success: false, error: `Unknown action: ${input.action}` });
-          }
-        },
-        {
-          name: "manage_task",
-          description: `\u7BA1\u7406\u6301\u4E45\u5316\u4EFB\u52A1\u7CFB\u7EDF\u3002CRUD \u64CD\u4F5C\u7528\u6237\u548C Agent \u7684\u4EFB\u52A1\u3002
-
-## ownerType \u548C ownerId \u7684\u9ED8\u8BA4\u903B\u8F91
-- \u4E0D\u4F20 ownerType \u548C ownerId: \u7CFB\u7EDF\u81EA\u52A8\u4E3A\u5F53\u524D\u7528\u6237\u521B\u5EFA\u4EFB\u52A1 (ownerType="user", ownerId \u53D6\u81EA\u5F53\u524D\u767B\u5F55\u7528\u6237)
-- \u4F20 ownerType="agent" \u4E0D\u4F20 ownerId: \u7CFB\u7EDF\u81EA\u52A8\u4E3A\u5F53\u524D Agent \u521B\u5EFA\u5B50\u4EFB\u52A1
-- \u663E\u5F0F\u4F20 ownerId: \u7CFB\u7EDF\u4F7F\u7528\u4F60\u6307\u5B9A\u7684 ID\uFF0C\u53EF\u8DE8 Agent \u6D3E\u53D1\u4EFB\u52A1\uFF08\u62D3\u6251\u573A\u666F\uFF09
-
-## Actions
-- create: \u521B\u5EFA\u4EFB\u52A1 (title \u5FC5\u586B, priority/description/dueDate/metadata/parentId/context \u53EF\u9009)
-- list: \u5217\u51FA\u4EFB\u52A1\uFF0C\u53EF\u6309 ownerType/status/priority \u8FC7\u6EE4
-- update: \u66F4\u65B0\u4EFB\u52A1 (id \u5FC5\u586B\uFF0C\u53EA\u4F20\u8981\u6539\u7684\u5B57\u6BB5)
-- delete: \u5220\u9664\u4EFB\u52A1 (id \u5FC5\u586B)
-- complete: \u5FEB\u901F\u6807\u8BB0\u5B8C\u6210 (id \u5FC5\u586B)`,
-          schema: manageTaskSchema
-        }
-      )
-    ]
-  });
-}
-var taskPlugin = {
-  meta: {
-    type: "task",
-    name: "Task Management",
-    description: "Enables persistent task management with delegation and tracking",
-    configSchema: {
-      type: "object",
-      title: "Task Management Configuration",
-      description: "Zero-configuration task management",
-      properties: {}
-    },
-    defaultConfig: {}
-  },
-  middleware: () => createTaskMiddleware()
-};
-
 // src/middlewares/evalMiddleware.ts
 import { createMiddleware as createMiddleware20, tool as tool61 } from "langchain";
 import { z as z66 } from "zod";
@@ -26974,7 +27807,7 @@ export {
   ExportableEntityRegistry,
   FileSystemSkillStore,
   FilesystemBackend,
-  HumanMessage4 as HumanMessage,
+  HumanMessage5 as HumanMessage,
   IdRemapper,
   InMemoryA2AApiKeyStore,
   InMemoryAssistantStore,
@@ -27023,6 +27856,8 @@ export {
   QueueMode,
   RemoteSandboxInstance,
   RemoteSandboxProvider,
+  STTModelLattice,
+  STTModelLatticeManager,
   SandboxFilesystem,
   SandboxLatticeManager,
   SandboxSkillStore,
@@ -27128,6 +27963,9 @@ export {
   getNextCronTime,
   getOrCreateCollectionVectorStore,
   getQueueLattice,
+  getSTTClient,
+  getSTTClientWithTenant,
+  getSTTModelLattice,
   getSandBoxManager,
   getScheduleLattice,
   getStoreLattice,
@@ -27171,6 +28009,7 @@ export {
   registerLoggerLattice,
   registerModelLattice,
   registerQueueLattice,
+  registerSTTModelLattice,
   registerSandboxProviderType,
   registerScheduleLattice,
   registerStoreLattice,
@@ -27192,6 +28031,7 @@ export {
   skillLatticeManager,
   sqlDatabaseManager,
   storeLatticeManager,
+  sttModelLatticeManager,
   toJsonSchema,
   toSafeStateExpr,
   toolLatticeManager,