@axiom-lattice/core 2.1.100 → 2.1.103

package/dist/index.js

@@ -874,7 +874,7 @@ Output must be valid JSON in exactly this shape. Return ONLY the JSON, no other
 ${example}`;
     prompt = prompt + schemaInstruction;
   }
-  return { messages: [new import_messages4.HumanMessage(prompt)] };
+  return { messages: [new import_messages5.HumanMessage(prompt)] };
 }
 function schemaToExample(schema6) {
   const example = schemaValueToExample(schema6);
@@ -1499,12 +1499,12 @@ function chunk(arr, size) {
   }
   return result;
 }
-var import_langgraph12, import_messages4;
+var import_langgraph12, import_messages5;
 var init_utils = __esm({
   "src/workflow/utils.ts"() {
     "use strict";
     import_langgraph12 = require("@langchain/langgraph");
-    import_messages4 = require("@langchain/core/messages");
+    import_messages5 = require("@langchain/core/messages");
     init_WorkflowAbortRegistry();
     init_parse_yaml();
   }
@@ -1634,7 +1634,7 @@ __export(index_exports, {
   ExportableEntityRegistry: () => ExportableEntityRegistry,
   FileSystemSkillStore: () => FileSystemSkillStore,
   FilesystemBackend: () => FilesystemBackend,
-  HumanMessage: () => import_messages6.HumanMessage,
+  HumanMessage: () => import_messages7.HumanMessage,
   IdRemapper: () => IdRemapper,
   InMemoryA2AApiKeyStore: () => InMemoryA2AApiKeyStore,
   InMemoryAssistantStore: () => InMemoryAssistantStore,
@@ -1683,6 +1683,8 @@ __export(index_exports, {
   QueueMode: () => QueueMode,
   RemoteSandboxInstance: () => RemoteSandboxInstance,
   RemoteSandboxProvider: () => RemoteSandboxProvider,
+  STTModelLattice: () => STTModelLattice,
+  STTModelLatticeManager: () => STTModelLatticeManager,
   SandboxFilesystem: () => SandboxFilesystem,
   SandboxLatticeManager: () => SandboxLatticeManager,
   SandboxSkillStore: () => SandboxSkillStore,
@@ -1788,6 +1790,9 @@ __export(index_exports, {
   getNextCronTime: () => getNextCronTime,
   getOrCreateCollectionVectorStore: () => getOrCreateCollectionVectorStore,
   getQueueLattice: () => getQueueLattice,
+  getSTTClient: () => getSTTClient,
+  getSTTClientWithTenant: () => getSTTClientWithTenant,
+  getSTTModelLattice: () => getSTTModelLattice,
   getSandBoxManager: () => getSandBoxManager,
   getScheduleLattice: () => getScheduleLattice,
   getStoreLattice: () => getStoreLattice,
@@ -1831,6 +1836,7 @@ __export(index_exports, {
   registerLoggerLattice: () => registerLoggerLattice,
   registerModelLattice: () => registerModelLattice,
   registerQueueLattice: () => registerQueueLattice,
+  registerSTTModelLattice: () => registerSTTModelLattice,
   registerSandboxProviderType: () => registerSandboxProviderType,
   registerScheduleLattice: () => registerScheduleLattice,
   registerStoreLattice: () => registerStoreLattice,
@@ -1852,6 +1858,7 @@ __export(index_exports, {
   skillLatticeManager: () => skillLatticeManager,
   sqlDatabaseManager: () => sqlDatabaseManager,
   storeLatticeManager: () => storeLatticeManager,
+  sttModelLatticeManager: () => sttModelLatticeManager,
   toJsonSchema: () => toJsonSchema,
   toSafeStateExpr: () => toSafeStateExpr,
   toolLatticeManager: () => toolLatticeManager,
@@ -1911,6 +1918,12 @@ var ModelLattice = class extends import_chat_models.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 工具列表
@@ -4479,11 +4492,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
     };
@@ -4509,6 +4528,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) {
@@ -4557,8 +4578,65 @@ var InMemoryTaskStore = class {
   }
 };
 
-// src/store_lattice/InMemoryCollectionStore.ts
+// src/store_lattice/InMemoryTaskWorkItemStore.ts
 var import_uuid2 = require("uuid");
+var InMemoryTaskWorkItemStore = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Create a new work item
+   */
+  async create(params) {
+    const id = (0, import_uuid2.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
+var import_uuid3 = require("uuid");
 var InMemoryCollectionStore = class {
   constructor() {
     this.collections = /* @__PURE__ */ new Map();
@@ -4592,7 +4670,7 @@ var InMemoryCollectionStore = class {
     }
     const now = /* @__PURE__ */ new Date();
     const collection = {
-      id: (0, import_uuid2.v4)(),
+      id: (0, import_uuid3.v4)(),
       tenantId: tenantId2,
       name: data.name,
       label: data.label,
@@ -4828,6 +4906,12 @@ storeLatticeManager.registerLattice(
   "task",
   defaultTaskStore
 );
+var defaultTaskWorkItemStore = new InMemoryTaskWorkItemStore();
+storeLatticeManager.registerLattice(
+  "default",
+  "taskWorkItem",
+  defaultTaskWorkItemStore
+);
 var defaultCollectionStore = new InMemoryCollectionStore();
 storeLatticeManager.registerLattice(
   "default",
@@ -8909,7 +8993,7 @@ var createBrowserGetInfoTool = ({ vmIsolation }) => {
 };
 
 // src/index.ts
-var import_messages6 = require("@langchain/core/messages");
+var import_messages7 = require("@langchain/core/messages");
 
 // src/agent_lattice/types.ts
 var import_protocols = require("@axiom-lattice/protocols");
@@ -9538,6 +9622,309 @@ 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
+var import_messages = require("@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 import_messages.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/STTModelLatticeManager.ts
+init_BaseLatticeManager();
+
+// src/stt_model_lattice/STTModelLattice.ts
+var import_openai2 = require("@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 import_openai2.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 (0, import_openai2.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 = import_v3.z.object({
   content: import_v3.z.array(import_v3.z.string()),
@@ -9596,7 +9983,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)";
@@ -9649,6 +10036,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);
     },
     {
@@ -10697,7 +11144,7 @@ var clawPlugin = {
 
 // src/middlewares/unknownToolHandlerMiddleware.ts
 var import_langchain44 = require("langchain");
-var import_messages = require("@langchain/core/messages");
+var import_messages2 = require("@langchain/core/messages");
 function createUnknownToolHandlerMiddleware(config = {}) {
   const {
     strategy = "error",
@@ -10747,7 +11194,7 @@ Please select a valid tool from the list above.`
         toolCallId: toolCall.id,
         errorMessage: errorMessageTemplate(toolCall.name, availableToolNames)
       }));
-      const modifiedResponse = new import_messages.AIMessage({
+      const modifiedResponse = new import_messages2.AIMessage({
         content: aiResponse.content,
         tool_calls: aiResponse.tool_calls,
         // Key: preserve all tool_calls, don't delete unknown
@@ -10778,7 +11225,7 @@ Please select a valid tool from the list above.`
           return;
         }
         const lastMessage = messages[messages.length - 1];
-        if (!import_messages.AIMessage.isInstance(lastMessage)) {
+        if (!import_messages2.AIMessage.isInstance(lastMessage)) {
           return;
         }
         const unknownToolErrors = lastMessage.response_metadata?._unknownToolErrors;
@@ -10786,7 +11233,7 @@ Please select a valid tool from the list above.`
           return;
         }
         const errorToolMessages = unknownToolErrors.map(
-          (error) => new import_messages.ToolMessage({
+          (error) => new import_messages2.ToolMessage({
             content: error.errorMessage,
             name: error.toolName,
             tool_call_id: error.toolCallId,
@@ -11242,19 +11689,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}`);
     }
@@ -11268,10 +11709,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}`);
     }
@@ -11368,13 +11806,13 @@ var ReActAgentGraphBuilder = class {
 };
 
 // src/deep_agent_new/agent.ts
-var import_langchain52 = require("langchain");
+var import_langchain53 = require("langchain");
 
 // src/deep_agent_new/middleware/subagents.ts
 var import_v32 = require("zod/v3");
-var import_langchain47 = require("langchain");
+var import_langchain48 = require("langchain");
 var import_langgraph7 = require("@langchain/langgraph");
-var import_messages2 = require("@langchain/core/messages");
+var import_messages3 = require("@langchain/core/messages");
 
 // src/agent_worker/agent_worker_graph.ts
 var import_langgraph5 = require("@langchain/langgraph");
@@ -12101,7 +12539,7 @@ var buffer = new InMemoryChunkBuffer({
 registerChunkBuffer("default", buffer);
 
 // src/services/Agent.ts
-var import_uuid3 = require("uuid");
+var import_uuid4 = require("uuid");
 var ThreadStatus2 = /* @__PURE__ */ ((ThreadStatus3) => {
   ThreadStatus3["IDLE"] = "idle";
   ThreadStatus3["BUSY"] = "busy";
@@ -12147,7 +12585,7 @@ var Agent = class {
               runConfig
             },
             configurable: {
-              run_id: (0, import_uuid3.v4)(),
+              run_id: (0, import_uuid4.v4)(),
               ...runConfig,
               runConfig
             },
@@ -12220,7 +12658,7 @@ var Agent = class {
               runConfig
             },
             configurable: {
-              run_id: (0, import_uuid3.v4)(),
+              run_id: (0, import_uuid4.v4)(),
               ...runConfig,
               runConfig
               // Inject runConfig for tools to access
@@ -12606,7 +13044,7 @@ var Agent = class {
     };
   }
   async invoke(queueMessage, signal) {
-    const messageId = (0, import_uuid3.v4)();
+    const messageId = (0, import_uuid4.v4)();
     const input = {
       ...queueMessage.input,
       messages: [new import_langchain46.HumanMessage({ id: messageId, content: queueMessage.input.message })]
@@ -12625,7 +13063,7 @@ var Agent = class {
    * to avoid exposing internal annotation data.
    */
   async invokeWithState(queueMessage, signal) {
-    const messageId = (0, import_uuid3.v4)();
+    const messageId = (0, import_uuid4.v4)();
     const input = {
       ...queueMessage.input,
       messages: [new import_langchain46.HumanMessage({ id: messageId, content: queueMessage.input.message })]
@@ -12641,7 +13079,7 @@ var Agent = class {
       {
         context: { runConfig },
         configurable: {
-          run_id: (0, import_uuid3.v4)(),
+          run_id: (0, import_uuid4.v4)(),
           ...runConfig,
           runConfig
         },
@@ -12817,7 +13255,7 @@ var Agent = class {
    */
   async addMessage(queueMessage, mode) {
     const useMode = mode ?? this.queueMode.mode;
-    const messageId = queueMessage.input.id || (0, import_uuid3.v4)();
+    const messageId = queueMessage.input.id || (0, import_uuid4.v4)();
     const messages = queueMessage.input.messages;
     const legacyMessage = queueMessage.input.message;
     if (!messages && !legacyMessage) {
@@ -13309,74 +13747,416 @@ 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>
+// src/middlewares/taskMiddleware.ts
+var import_langchain47 = require("langchain");
+var import_zod44 = require("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 = import_zod44.z.object({
+  action: import_zod44.z.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: import_zod44.z.string().optional().describe("Task ID (required for update and delete)"),
+  title: import_zod44.z.string().optional().describe("Task title (required for create)"),
+  description: import_zod44.z.string().optional().describe("Task description in Markdown"),
+  priority: import_zod44.z.enum(["low", "medium", "high"]).optional().describe("Priority level"),
+  status: import_zod44.z.enum(["pending", "in_progress", "review", "failed", "interrupted", "completed", "cancelled"]).optional().describe("Task status"),
+  dueDate: import_zod44.z.string().optional().describe("Due date (ISO 8601 format)"),
+  metadata: import_zod44.z.record(import_zod44.z.unknown()).optional().describe("Structured metadata (e.g. projectId, module)"),
+  parentId: import_zod44.z.string().optional().describe("Parent task ID for grouping subtasks"),
+  sourceId: import_zod44.z.string().optional().describe("Source session/thread ID"),
+  context: import_zod44.z.record(import_zod44.z.unknown()).optional().describe("Additional context data"),
+  ownerType: import_zod44.z.enum(["user", "agent"]).optional().describe("Owner type. Defaults to 'user' if omitted"),
+  ownerId: import_zod44.z.string().optional().describe("Owner ID. Auto-filled from current user/agent if omitted"),
+  requireReview: import_zod44.z.boolean().optional().describe("If true, completing sends task to 'review' status instead of 'completed'"),
+  dependencies: import_zod44.z.array(import_zod44.z.string()).optional().describe("List of task IDs that must be completed before this task can start"),
+  result: import_zod44.z.string().optional().describe("Result summary when task is completed"),
+  failureReason: import_zod44.z.string().optional().describe("Reason for failure (use when status='failed')"),
+  summary: import_zod44.z.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 (0, import_langchain47.createMiddleware)({
+    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: [
+      (0, import_langchain47.tool)(
+        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:
@@ -13470,7 +14250,7 @@ function returnCommandWithStateUpdate(result, toolCallId) {
     update: {
       ...stateUpdate,
       messages: [
-        new import_langchain47.ToolMessage({
+        new import_langchain48.ToolMessage({
           content: lastMessage?.content || "Task Failed to complete",
           tool_call_id: toolCallId,
           name: "task"
@@ -13491,14 +14271,18 @@ 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(
-        (0, import_langchain47.humanInTheLoopMiddleware)({ interruptOn: defaultInterruptOn })
+        (0, import_langchain48.humanInTheLoopMiddleware)({ interruptOn: defaultInterruptOn })
       );
     }
-    const generalPurposeSubagent = (0, import_langchain47.createAgent)({
+    const generalPurposeSubagent = (0, import_langchain48.createAgent)({
       model: defaultModel,
       systemPrompt: DEFAULT_SUBAGENT_PROMPT,
       tools: defaultTools,
@@ -13518,11 +14302,11 @@ 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((0, import_langchain47.humanInTheLoopMiddleware)({ interruptOn }));
-      agents[agentParams.key] = (0, import_langchain47.createAgent)({
+        middleware.push((0, import_langchain48.humanInTheLoopMiddleware)({ interruptOn }));
+      agents[agentParams.key] = (0, import_langchain48.createAgent)({
         model: agentParams.model ?? defaultModel,
         systemPrompt: agentParams.systemPrompt,
         tools: agentParams.tools ?? defaultTools,
@@ -13572,7 +14356,7 @@ function createTaskTool(options) {
     generalPurposeAgent
   });
   const finalTaskDescription = taskDescription ? taskDescription : getTaskToolDescription(subagentDescriptions);
-  return (0, import_langchain47.tool)(
+  return (0, import_langchain48.tool)(
     async (input, config) => {
       const { description, subagent_type, async } = input;
       let assistant_id = subagent_type;
@@ -13602,7 +14386,17 @@ function createTaskTool(options) {
         }
         const currentState = (0, import_langgraph7.getCurrentTaskInput)();
         const subagentState = filterStateForSubagent(currentState);
-        subagentState.messages = [new import_messages2.HumanMessage({ content: description })];
+        subagentState.messages = input.taskId ? [
+          new import_messages3.HumanMessage({
+            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 import_messages3.HumanMessage({ content: description })];
         const subagent_thread_id = config.configurable?.thread_id + "____" + assistant_id + "_" + config.toolCall.id;
         if (async) {
           const tenantId2 = config.configurable?.runConfig?.tenantId;
@@ -13634,11 +14428,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);
           });
@@ -13648,7 +14443,7 @@ function createTaskTool(options) {
           return new import_langgraph7.Command({
             update: {
               messages: [
-                new import_langchain47.ToolMessage({
+                new import_langchain48.ToolMessage({
                   content: `Async task started: ${subagent_thread_id}
 ${description}
 The result will be delivered as a notification when complete. Do not poll.`,
@@ -13666,7 +14461,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;
@@ -13681,7 +14477,7 @@ The result will be delivered as a notification when complete. Do not poll.`,
         return new import_langgraph7.Command({
           update: {
             messages: [
-              new import_langchain47.ToolMessage({
+              new import_langchain48.ToolMessage({
                 content: error instanceof Error ? error.message : "Task Failed to complete",
                 tool_call_id: config.toolCall.id,
                 name: "task"
@@ -13705,7 +14501,10 @@ The result will be delivered as a notification when complete. Do not poll.`,
           async: import_v32.z.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: import_v32.z.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."
+        )
       })
     }
   );
@@ -13721,7 +14520,7 @@ function getMainAgentFromConfig(config) {
   });
 }
 function createCheckAsyncTaskTool() {
-  return (0, import_langchain47.tool)(
+  return (0, import_langchain48.tool)(
     async (input, config) => {
       const { task_id } = input;
       const mainAgent = getMainAgentFromConfig(config);
@@ -13788,7 +14587,7 @@ Description: ${cached.description}`;
   );
 }
 function createListAsyncTasksTool() {
-  return (0, import_langchain47.tool)(
+  return (0, import_langchain48.tool)(
     async (_input, config) => {
       const mainAgent = getMainAgentFromConfig(config);
       if (!mainAgent) {
@@ -13839,7 +14638,7 @@ function createListAsyncTasksTool() {
   );
 }
 function createCancelAsyncTaskTool() {
-  return (0, import_langchain47.tool)(
+  return (0, import_langchain48.tool)(
     async (input, config) => {
       const { task_id } = input;
       const mainAgent = getMainAgentFromConfig(config);
@@ -13915,7 +14714,7 @@ function createSubAgentMiddleware(options) {
     );
   }
   const effectiveSystemPrompt = allowAsync ? systemPrompt + getAsyncPromptText() : systemPrompt;
-  return (0, import_langchain47.createMiddleware)({
+  return (0, import_langchain48.createMiddleware)({
     name: "subAgentMiddleware",
     tools: allTools,
     wrapModelCall: async (request, handler) => {
@@ -13935,9 +14734,9 @@ ${effectiveSystemPrompt}` : effectiveSystemPrompt;
 }
 
 // src/deep_agent_new/middleware/patch_tool_calls.ts
-var import_langchain48 = require("langchain");
+var import_langchain49 = require("langchain");
 function createPatchToolCallsMiddleware() {
-  return (0, import_langchain48.createMiddleware)({
+  return (0, import_langchain49.createMiddleware)({
     name: "patchToolCallsMiddleware",
     beforeAgent: async (state) => {
       const messages = state.messages;
@@ -13948,15 +14747,15 @@ function createPatchToolCallsMiddleware() {
       for (let i = 0; i < messages.length; i++) {
         const msg = messages[i];
         patchedMessages.push(msg);
-        if (import_langchain48.AIMessage.isInstance(msg) && msg.tool_calls != null) {
+        if (import_langchain49.AIMessage.isInstance(msg) && msg.tool_calls != null) {
           for (const toolCall of msg.tool_calls) {
             const correspondingToolMsg = messages.slice(i).find(
-              (m) => import_langchain48.ToolMessage.isInstance(m) && m.tool_call_id === toolCall.id
+              (m) => import_langchain49.ToolMessage.isInstance(m) && m.tool_call_id === toolCall.id
             );
             if (!correspondingToolMsg) {
               const toolMsg = `Tool call ${toolCall.name} with id ${toolCall.id} was cancelled - another message came in before it could be completed.`;
               patchedMessages.push(
-                new import_langchain48.ToolMessage({
+                new import_langchain49.ToolMessage({
                   content: toolMsg,
                   name: toolCall.name,
                   tool_call_id: toolCall.id
@@ -13978,8 +14777,8 @@ function createPatchToolCallsMiddleware() {
 }
 
 // src/deep_agent_new/middleware/date.ts
-var import_langchain49 = require("langchain");
-var import_zod44 = require("zod");
+var import_langchain50 = require("langchain");
+var import_zod45 = require("zod");
 function formatCurrentDate(timezone = "UTC") {
   const now = /* @__PURE__ */ new Date();
   let validTimezone = timezone;
@@ -14007,10 +14806,10 @@ function generateDateContext(timezone = "UTC") {
 function createDateMiddleware(options = {}) {
   const timezone = options.timezone || "UTC";
   const dateContext = generateDateContext(timezone);
-  return (0, import_langchain49.createMiddleware)({
+  return (0, import_langchain50.createMiddleware)({
     name: "DateMiddleware",
     tools: [
-      (0, import_langchain49.tool)(
+      (0, import_langchain50.tool)(
         async () => {
           const now = /* @__PURE__ */ new Date();
           let validTimezone = timezone;
@@ -14040,7 +14839,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: import_zod44.z.object({})
+          schema: import_zod45.z.object({})
         }
       )
     ],
@@ -14105,9 +14904,9 @@ var datePlugin = {
 };
 
 // src/deep_agent_new/middleware/scheduler.ts
-var import_langchain50 = require("langchain");
-var import_zod45 = require("zod");
-var import_uuid4 = require("uuid");
+var import_langchain51 = require("langchain");
+var import_zod46 = require("zod");
+var import_uuid5 = require("uuid");
 var import_protocols8 = require("@axiom-lattice/protocols");
 
 // src/schedule_lattice/ScheduleLatticeManager.ts
@@ -15102,7 +15901,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 ?? {};
 }
@@ -15174,14 +15973,14 @@ function registerAgentAddMessageHandler() {
 function createSchedulerMiddleware(options = {}) {
   const defaultMaxRetries = options.defaultMaxRetries ?? 0;
   registerAgentAddMessageHandler();
-  return (0, import_langchain50.createMiddleware)({
+  return (0, import_langchain51.createMiddleware)({
     name: "SchedulerMiddleware",
     tools: [
-      (0, import_langchain50.tool)(
+      (0, import_langchain51.tool)(
         async (input, config) => {
-          const runConfig = getRunConfig(config);
+          const runConfig = getRunConfig2(config);
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
-          const taskId = (0, import_uuid4.v4)();
+          const taskId = (0, import_uuid5.v4)();
           const executeAt = input.executeAt;
           const success = await scheduleLattice.client.scheduleOnce(
             taskId,
@@ -15205,18 +16004,18 @@ function createSchedulerMiddleware(options = {}) {
         {
           name: "schedule_at",
           description: "Schedule a system message for an absolute future timestamp",
-          schema: import_zod45.z.object({
-            executeAt: import_zod45.z.number(),
-            maxRetries: import_zod45.z.number().int().min(0).optional(),
-            message: import_zod45.z.string()
+          schema: import_zod46.z.object({
+            executeAt: import_zod46.z.number(),
+            maxRetries: import_zod46.z.number().int().min(0).optional(),
+            message: import_zod46.z.string()
           })
         }
       ),
-      (0, import_langchain50.tool)(
+      (0, import_langchain51.tool)(
         async (input, config) => {
-          const runConfig = getRunConfig(config);
+          const runConfig = getRunConfig2(config);
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
-          const taskId = (0, import_uuid4.v4)();
+          const taskId = (0, import_uuid5.v4)();
           const executeAt = Date.now() + input.delayMs;
           const success = await scheduleLattice.client.scheduleOnce(
             taskId,
@@ -15240,18 +16039,18 @@ function createSchedulerMiddleware(options = {}) {
         {
           name: "schedule_after",
           description: "Schedule a system message after a relative delay",
-          schema: import_zod45.z.object({
-            delayMs: import_zod45.z.number().positive(),
-            maxRetries: import_zod45.z.number().int().min(0).optional(),
-            message: import_zod45.z.string()
+          schema: import_zod46.z.object({
+            delayMs: import_zod46.z.number().positive(),
+            maxRetries: import_zod46.z.number().int().min(0).optional(),
+            message: import_zod46.z.string()
           })
         }
       ),
-      (0, import_langchain50.tool)(
+      (0, import_langchain51.tool)(
         async (input, config) => {
-          const runConfig = getRunConfig(config);
+          const runConfig = getRunConfig2(config);
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
-          const taskId = (0, import_uuid4.v4)();
+          const taskId = (0, import_uuid5.v4)();
           const success = await scheduleLattice.client.scheduleCron(
             taskId,
             AGENT_ADD_MESSAGE_TASK_TYPE,
@@ -15282,16 +16081,16 @@ function createSchedulerMiddleware(options = {}) {
         {
           name: "schedule_recurring",
           description: "Schedule a recurring system message with a cron expression",
-          schema: import_zod45.z.object({
-            cronExpression: import_zod45.z.string(),
-            maxRuns: import_zod45.z.number().int().positive().optional(),
-            expiresAt: import_zod45.z.number().optional(),
-            maxRetries: import_zod45.z.number().int().min(0).optional(),
-            message: import_zod45.z.string()
+          schema: import_zod46.z.object({
+            cronExpression: import_zod46.z.string(),
+            maxRuns: import_zod46.z.number().int().positive().optional(),
+            expiresAt: import_zod46.z.number().optional(),
+            maxRetries: import_zod46.z.number().int().min(0).optional(),
+            message: import_zod46.z.string()
           })
         }
       ),
-      (0, import_langchain50.tool)(
+      (0, import_langchain51.tool)(
         async (input) => {
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
           const success = await scheduleLattice.client.cancel(input.taskId);
@@ -15300,14 +16099,14 @@ function createSchedulerMiddleware(options = {}) {
         {
           name: "cancel_scheduled_task",
           description: "Cancel a scheduled task by task id",
-          schema: import_zod45.z.object({
-            taskId: import_zod45.z.string()
+          schema: import_zod46.z.object({
+            taskId: import_zod46.z.string()
           })
         }
       ),
-      (0, import_langchain50.tool)(
+      (0, import_langchain51.tool)(
         async (input, config) => {
-          const runConfig = getRunConfig(config);
+          const runConfig = getRunConfig2(config);
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
           const storage = scheduleLattice.client.getStorage();
           if (!storage) {
@@ -15327,11 +16126,11 @@ function createSchedulerMiddleware(options = {}) {
         {
           name: "list_scheduled_tasks",
           description: "List scheduled tasks for the current agent context",
-          schema: import_zod45.z.object({
-            status: import_zod45.z.enum(["pending", "running", "completed", "failed", "cancelled", "paused"]).optional(),
-            executionType: import_zod45.z.enum(["once", "cron"]).optional(),
-            limit: import_zod45.z.number().int().positive().optional(),
-            offset: import_zod45.z.number().int().min(0).optional()
+          schema: import_zod46.z.object({
+            status: import_zod46.z.enum(["pending", "running", "completed", "failed", "cancelled", "paused"]).optional(),
+            executionType: import_zod46.z.enum(["once", "cron"]).optional(),
+            limit: import_zod46.z.number().int().positive().optional(),
+            offset: import_zod46.z.number().int().min(0).optional()
           })
         }
       )
@@ -16472,8 +17271,8 @@ var MemoryBackend = class {
 
 // src/deep_agent_new/middleware/todos.ts
 var import_langgraph8 = require("@langchain/langgraph");
-var import_zod46 = require("zod");
-var import_langchain51 = require("langchain");
+var import_zod47 = require("zod");
+var import_langchain52 = require("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.
@@ -16700,20 +17499,20 @@ 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 = import_zod46.z.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
-var TodoSchema = import_zod46.z.object({
-  content: import_zod46.z.string().describe("Content of the todo item"),
+var TodoStatus = import_zod47.z.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
+var TodoSchema = import_zod47.z.object({
+  content: import_zod47.z.string().describe("Content of the todo item"),
   status: TodoStatus
 });
-var stateSchema = import_zod46.z.object({ todos: import_zod46.z.array(TodoSchema).default([]) });
+var stateSchema = import_zod47.z.object({ todos: import_zod47.z.array(TodoSchema).default([]) });
 function todoListMiddleware(options) {
-  const writeTodos = (0, import_langchain51.tool)(
+  const writeTodos = (0, import_langchain52.tool)(
     ({ todos }, config) => {
       return new import_langgraph8.Command({
         update: {
           todos,
           messages: [
-            new import_langchain51.ToolMessage({
+            new import_langchain52.ToolMessage({
               content: genUIMarkdown("todo_list", todos),
               tool_call_id: config.toolCall?.id
             })
@@ -16724,12 +17523,12 @@ function todoListMiddleware(options) {
     {
       name: "write_todos",
       description: options?.toolDescription ?? WRITE_TODOS_DESCRIPTION,
-      schema: import_zod46.z.object({
-        todos: import_zod46.z.array(TodoSchema).describe("List of todo items to update")
+      schema: import_zod47.z.object({
+        todos: import_zod47.z.array(TodoSchema).describe("List of todo items to update")
       })
     }
   );
-  return (0, import_langchain51.createMiddleware)({
+  return (0, import_langchain52.createMiddleware)({
     name: "todoListMiddleware",
     stateSchema,
     tools: [writeTodos],
@@ -16781,13 +17580,13 @@ ${BASE_PROMPT}` : BASE_PROMPT;
           backend: filesystemBackend
         }),
         // Subagent middleware: Automatic conversation summarization when token limits are approached
-        (0, import_langchain52.summarizationMiddleware)({
+        (0, import_langchain53.summarizationMiddleware)({
           model,
           trigger: { tokens: 17e4 },
           keep: { messages: 6 }
         }),
         // Subagent middleware: Anthropic prompt caching for improved performance
-        (0, import_langchain52.anthropicPromptCachingMiddleware)({
+        (0, import_langchain53.anthropicPromptCachingMiddleware)({
           unsupportedModelBehavior: "ignore"
         }),
         // Subagent middleware: Patches tool calls for compatibility
@@ -16799,23 +17598,23 @@ ${BASE_PROMPT}` : BASE_PROMPT;
       generalPurposeAgent: true
     }),
     // Automatically summarizes conversation history when token limits are approached
-    (0, import_langchain52.summarizationMiddleware)({
+    (0, import_langchain53.summarizationMiddleware)({
       model,
       trigger: { tokens: 17e4 },
       keep: { messages: 6 }
     }),
     // Enables Anthropic prompt caching for improved performance and reduced costs
-    (0, import_langchain52.anthropicPromptCachingMiddleware)({
+    (0, import_langchain53.anthropicPromptCachingMiddleware)({
       unsupportedModelBehavior: "ignore"
     }),
     // Patches tool calls to ensure compatibility across different model providers
     createPatchToolCallsMiddleware()
   ];
   if (interruptOn) {
-    middleware.push((0, import_langchain52.humanInTheLoopMiddleware)({ interruptOn }));
+    middleware.push((0, import_langchain53.humanInTheLoopMiddleware)({ interruptOn }));
   }
   middleware.push(...customMiddleware);
-  return (0, import_langchain52.createAgent)({
+  return (0, import_langchain53.createAgent)({
     model,
     systemPrompt: finalSystemPrompt,
     tools,
@@ -16887,7 +17686,7 @@ init_MemoryLatticeManager();
 
 // src/agent_team/agent_team.ts
 var import_v35 = require("zod/v3");
-var import_langchain55 = require("langchain");
+var import_langchain56 = require("langchain");
 
 // src/agent_team/types.ts
 var TaskStatus = /* @__PURE__ */ ((TaskStatus3) => {
@@ -17323,13 +18122,13 @@ var InMemoryMailboxStore = class {
 
 // src/agent_team/middleware/team.ts
 var import_v34 = require("zod/v3");
-var import_langchain54 = require("langchain");
+var import_langchain55 = require("langchain");
 var import_langgraph10 = require("@langchain/langgraph");
-var import_uuid5 = require("uuid");
+var import_uuid6 = require("uuid");
 
 // src/agent_team/middleware/teammate_tools.ts
 var import_v33 = require("zod/v3");
-var import_langchain53 = require("langchain");
+var import_langchain54 = require("langchain");
 var import_langgraph9 = require("@langchain/langgraph");
 
 // src/agent_team/middleware/formatMessages.ts
@@ -17354,7 +18153,7 @@ ${meta}${body}`;
 // src/agent_team/middleware/teammate_tools.ts
 function createTeammateTools(options) {
   const { teamId, agentId, taskListStore, mailboxStore } = options;
-  const claimTaskTool = (0, import_langchain53.tool)(
+  const claimTaskTool = (0, import_langchain54.tool)(
     async (input) => {
       const task = await taskListStore.claimTaskById(
         teamId,
@@ -17384,7 +18183,7 @@ function createTeammateTools(options) {
       })
     }
   );
-  const completeTaskTool = (0, import_langchain53.tool)(
+  const completeTaskTool = (0, import_langchain54.tool)(
     async (input) => {
       const task = await taskListStore.completeTask(
         teamId,
@@ -17411,7 +18210,7 @@ function createTeammateTools(options) {
       })
     }
   );
-  const failTaskTool = (0, import_langchain53.tool)(
+  const failTaskTool = (0, import_langchain54.tool)(
     async (input) => {
       const task = await taskListStore.failTask(
         teamId,
@@ -17438,7 +18237,7 @@ function createTeammateTools(options) {
       })
     }
   );
-  const sendMessageTool = (0, import_langchain53.tool)(
+  const sendMessageTool = (0, import_langchain54.tool)(
     async (input) => {
       await mailboxStore.sendMessage(
         teamId,
@@ -17476,7 +18275,7 @@ function createTeammateTools(options) {
       read: msg.read
     }));
   };
-  const readMessagesTool = (0, import_langchain53.tool)(
+  const readMessagesTool = (0, import_langchain54.tool)(
     async (input, config) => {
       const formatAndMarkAsRead = async (msgs2) => {
         for (const msg of msgs2) {
@@ -17488,7 +18287,7 @@ function createTeammateTools(options) {
       if (msgs.length > 0) {
         const formatted2 = await formatAndMarkAsRead(msgs);
         const relevantMsgs2 = await getRelevantMessagesForState();
-        const toolMessage2 = new import_langchain53.ToolMessage({
+        const toolMessage2 = new import_langchain54.ToolMessage({
           content: formatted2,
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -17513,7 +18312,7 @@ function createTeammateTools(options) {
       });
       const relevantMsgs = await getRelevantMessagesForState();
       if (msgs.length === 0) {
-        const toolMessage2 = new import_langchain53.ToolMessage({
+        const toolMessage2 = new import_langchain54.ToolMessage({
           content: "No unread messages.",
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -17523,7 +18322,7 @@ function createTeammateTools(options) {
         });
       }
       const formatted = await formatAndMarkAsRead(msgs);
-      const toolMessage = new import_langchain53.ToolMessage({
+      const toolMessage = new import_langchain54.ToolMessage({
         content: formatted,
         tool_call_id: config.toolCall?.id,
         name: "read_messages"
@@ -17538,7 +18337,7 @@ function createTeammateTools(options) {
       schema: import_v33.z.object({})
     }
   );
-  const checkTasksTool = (0, import_langchain53.tool)(
+  const checkTasksTool = (0, import_langchain54.tool)(
     async () => {
       const tasks = await taskListStore.getAllTasks(teamId);
       return formatTaskSummary(tasks);
@@ -17549,7 +18348,7 @@ function createTeammateTools(options) {
       schema: import_v33.z.object({})
     }
   );
-  const broadcastMessageTool = (0, import_langchain53.tool)(
+  const broadcastMessageTool = (0, import_langchain54.tool)(
     async (input) => {
       const allAgents = await mailboxStore.getRegisteredAgents(teamId);
       const recipients = allAgents.filter((a) => a !== agentId);
@@ -17735,7 +18534,7 @@ You have access to these tools:
 - \`read_messages\`: Read messages from team_lead or teammates
 - \`check_tasks\`: Get current status of all tasks in the team`;
   const assistantId = getTeammateAssistantId(ctx.teamId, spec.name);
-  agent = (0, import_langchain54.createAgent)({
+  agent = (0, import_langchain55.createAgent)({
     model: spec.model ?? ctx.defaultModel,
     systemPrompt: teammatePrompt,
     tools: allTools,
@@ -17804,19 +18603,19 @@ 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 = (0, import_langchain54.tool)(
+  const createTeamTool = (0, import_langchain55.tool)(
     async (input, config) => {
       const state = (0, import_langgraph10.getCurrentTaskInput)();
       if (state?.team?.teamId) {
         const existingId = state.team.teamId;
-        const msg = new import_langchain54.ToolMessage({
+        const msg = new import_langchain55.ToolMessage({
           content: `A team is already active (id: ${existingId}). Use this team_id for \`check_tasks\`, \`read_messages\`, \`add_tasks\`, \`send_message\`, \`assign_task\`, \`set_task_status\`, and \`set_task_dependencies\`. Do not call \`create_team\` again unless you need a fresh team for a new objective.`,
           tool_call_id: config.toolCall?.id,
           name: "create_team"
         });
         return msg;
       }
-      const teamId = (0, import_uuid5.v4)();
+      const teamId = (0, import_uuid6.v4)();
       const createdTasks = await taskListStore.addTasks(
         teamId,
         input.tasks.map((t) => ({
@@ -17898,7 +18697,7 @@ Teammates are now working in the background. Keep calling \`check_tasks\` and \`
 \`\`\`json
 ${teamJson}
 \`\`\``;
-      const toolMessage = new import_langchain54.ToolMessage({
+      const toolMessage = new import_langchain55.ToolMessage({
         content: summary,
         tool_call_id: config.toolCall?.id,
         name: "create_team"
@@ -17983,7 +18782,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 = (0, import_langchain54.tool)(
+  const addTasksTool = (0, import_langchain55.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const created = await taskListStore.addTasks(
@@ -17997,7 +18796,7 @@ After calling create_team, you MUST:
         }))
       );
       const summary = created.map((t) => `- ${t.id}: "${t.title}"`).join("\n");
-      return new import_langchain54.ToolMessage({
+      return new import_langchain55.ToolMessage({
         content: `Added ${created.length} task(s) to team ${teamId}:
 ${summary}
 Sleeping teammates will wake up and claim these.`,
@@ -18048,20 +18847,20 @@ IMPORTANT: Assigning to a specific teammate
       })
     }
   );
-  const assignTaskTool = (0, import_langchain54.tool)(
+  const assignTaskTool = (0, import_langchain55.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
         assignee: input.assignee
       });
       if (!task) {
-        return new import_langchain54.ToolMessage({
+        return new import_langchain55.ToolMessage({
           content: `Task ${input.task_id} not found in team ${teamId}.`,
           tool_call_id: config.toolCall?.id,
           name: "assign_task"
         });
       }
-      return new import_langchain54.ToolMessage({
+      return new import_langchain55.ToolMessage({
         content: `Task "${task.title}" (${task.id}) assigned to ${input.assignee}.`,
         tool_call_id: config.toolCall?.id,
         name: "assign_task"
@@ -18076,20 +18875,20 @@ IMPORTANT: Assigning to a specific teammate
       })
     }
   );
-  const setTaskStatusTool = (0, import_langchain54.tool)(
+  const setTaskStatusTool = (0, import_langchain55.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
         status: input.status
       });
       if (!task) {
-        return new import_langchain54.ToolMessage({
+        return new import_langchain55.ToolMessage({
           content: `Task ${input.task_id} not found in team ${teamId}.`,
           tool_call_id: config.toolCall?.id,
           name: "set_task_status"
         });
       }
-      return new import_langchain54.ToolMessage({
+      return new import_langchain55.ToolMessage({
         content: `Task "${task.title}" (${task.id}) status set to ${input.status}.`,
         tool_call_id: config.toolCall?.id,
         name: "set_task_status"
@@ -18104,20 +18903,20 @@ IMPORTANT: Assigning to a specific teammate
       })
     }
   );
-  const setTaskDependenciesTool = (0, import_langchain54.tool)(
+  const setTaskDependenciesTool = (0, import_langchain55.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
         dependencies: input.dependencies
       });
       if (!task) {
-        return new import_langchain54.ToolMessage({
+        return new import_langchain55.ToolMessage({
           content: `Task ${input.task_id} not found in team ${teamId}.`,
           tool_call_id: config.toolCall?.id,
           name: "set_task_dependencies"
         });
       }
-      return new import_langchain54.ToolMessage({
+      return new import_langchain55.ToolMessage({
         content: `Task "${task.title}" (${task.id}) dependencies set to [${input.dependencies.join(", ")}].`,
         tool_call_id: config.toolCall?.id,
         name: "set_task_dependencies"
@@ -18132,7 +18931,7 @@ IMPORTANT: Assigning to a specific teammate
       })
     }
   );
-  const checkTasksTool = (0, import_langchain54.tool)(
+  const checkTasksTool = (0, import_langchain55.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const tasks = await taskListStore.getAllTasks(teamId);
@@ -18141,7 +18940,7 @@ IMPORTANT: Assigning to a specific teammate
         update: {
           tasks: tasksSnapshot,
           messages: [
-            new import_langchain54.ToolMessage({
+            new import_langchain55.ToolMessage({
               content: formatTaskSummary(tasks),
               tool_call_id: config.toolCall?.id,
               name: "check_tasks"
@@ -18177,7 +18976,7 @@ Task Status Values:
       })
     }
   );
-  const sendMessageTool = (0, import_langchain54.tool)(
+  const sendMessageTool = (0, import_langchain55.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.sendMessage(
@@ -18187,7 +18986,7 @@ Task Status Values:
         input.content,
         "direct_message" /* DIRECT_MESSAGE */
       );
-      return new import_langchain54.ToolMessage({
+      return new import_langchain55.ToolMessage({
         content: `Message sent to ${input.to}.`,
         tool_call_id: config.toolCall?.id,
         name: "send_message"
@@ -18202,7 +19001,7 @@ Task Status Values:
       })
     }
   );
-  const readMessagesTool = (0, import_langchain54.tool)(
+  const readMessagesTool = (0, import_langchain55.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const formatAndMarkAsRead = async (msgs2) => {
@@ -18230,7 +19029,7 @@ Task Status Values:
       if (msgs.length > 0) {
         const formatted2 = await formatAndMarkAsRead(msgs);
         const allTeamMessages2 = await getAllTeamMessagesForState();
-        const toolMessage2 = new import_langchain54.ToolMessage({
+        const toolMessage2 = new import_langchain55.ToolMessage({
           content: formatted2,
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -18262,7 +19061,7 @@ Task Status Values:
       );
       const allTeamMessages = await getAllTeamMessagesForState();
       if (msgs.length === 0) {
-        const toolMessage2 = new import_langchain54.ToolMessage({
+        const toolMessage2 = new import_langchain55.ToolMessage({
           content: "No unread messages from teammates.",
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -18272,7 +19071,7 @@ Task Status Values:
         });
       }
       const formatted = await formatAndMarkAsRead(msgs);
-      const toolMessage = new import_langchain54.ToolMessage({
+      const toolMessage = new import_langchain55.ToolMessage({
         content: formatted,
         tool_call_id: config.toolCall?.id,
         name: "read_messages"
@@ -18289,7 +19088,7 @@ Task Status Values:
       })
     }
   );
-  const disbandTeamTool = (0, import_langchain54.tool)(
+  const disbandTeamTool = (0, import_langchain55.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -18299,7 +19098,7 @@ Task Status Values:
         "shutdown_request" /* SHUTDOWN_REQUEST */
       );
       await new Promise((r) => setTimeout(r, 2e3));
-      return new import_langchain54.ToolMessage({
+      return new import_langchain55.ToolMessage({
         content: `Team ${teamId} has been disbanded. All teammates notified and resources cleaned up.`,
         tool_call_id: config.toolCall?.id,
         name: "disband_team"
@@ -18310,7 +19109,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 = (0, import_langchain54.tool)(
+  const broadcastMessageTool = (0, import_langchain55.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -18319,7 +19118,7 @@ Task Status Values:
         input.content,
         "broadcast" /* BROADCAST */
       );
-      return new import_langchain54.ToolMessage({
+      return new import_langchain55.ToolMessage({
         content: `Broadcast message sent to all teammates.`,
         tool_call_id: config.toolCall?.id,
         name: "broadcast_message"
@@ -18333,7 +19132,7 @@ Task Status Values:
       })
     }
   );
-  return (0, import_langchain54.createMiddleware)({
+  return (0, import_langchain55.createMiddleware)({
     name: "teamMiddleware",
     tools: [
       createTeamTool,
@@ -18442,7 +19241,7 @@ function createAgentTeam(config) {
   ];
   const systemPrompt = config.systemPrompt + "\n\n" + TEAM_LEAD_BASE_PROMPT;
   const stateSchema2 = createReactAgentSchema(TEAM_STATE_SCHEMA);
-  return (0, import_langchain55.createAgent)({
+  return (0, import_langchain56.createAgent)({
     model: config.model ?? "claude-sonnet-4-5-20250929",
     systemPrompt,
     tools: [],
@@ -18511,10 +19310,10 @@ var TeamAgentGraphBuilder = class {
 
 // src/agent_lattice/builders/RemoteAgentGraphBuilder.ts
 var import_langgraph11 = require("@langchain/langgraph");
-var import_messages3 = require("@langchain/core/messages");
+var import_messages4 = require("@langchain/core/messages");
 
 // src/services/a2a-client.ts
-var import_uuid6 = require("uuid");
+var import_uuid7 = require("uuid");
 var A2ARemoteError = class extends Error {
   constructor(message, statusCode, body) {
     super(message);
@@ -18561,7 +19360,7 @@ var A2ARemoteClient = class {
    */
   async sendMessage(text) {
     await this.resolve();
-    const taskId = (0, import_uuid6.v4)();
+    const taskId = (0, import_uuid7.v4)();
     const body = JSON.stringify({
       jsonrpc: "2.0",
       method: "tasks/send",
@@ -18687,7 +19486,7 @@ var RemoteAgentGraphBuilder = class {
       if (!text) {
         return {
           messages: [
-            new import_messages3.AIMessage("No text input provided to remote agent.")
+            new import_messages4.AIMessage("No text input provided to remote agent.")
           ]
         };
       }
@@ -18698,13 +19497,13 @@ User request:
 ${text}` : text;
         const response = await client.sendMessage(fullPrompt);
         return {
-          messages: [new import_messages3.AIMessage(response)]
+          messages: [new import_messages4.AIMessage(response)]
         };
       } catch (error) {
         const msg = error.message ?? String(error);
         return {
           messages: [
-            new import_messages3.AIMessage(`Remote A2A agent error: ${msg}`)
+            new import_messages4.AIMessage(`Remote A2A agent error: ${msg}`)
           ]
         };
       }
@@ -18731,7 +19530,7 @@ function extractLastHumanMessage(messages) {
 }
 
 // src/agent_lattice/builders/WorkflowAgentGraphBuilder.ts
-var import_langchain56 = require("langchain");
+var import_langchain57 = require("langchain");
 init_MemoryLatticeManager();
 var import_protocols10 = require("@axiom-lattice/protocols");
 init_compile();
@@ -18796,7 +19595,7 @@ var WorkflowAgentGraphBuilder = class {
     const noWrapMiddlewares = stripWrapModelCallHook(middlewares);
     const noWrapAskMiddlewares = stripWrapModelCallHook(askMiddlewares);
     console.log(`[WF BUILDER] building default agent | toolCount=${tools.length} | middlewareCount=${middlewares.length}`);
-    const defaultAgent = (0, import_langchain56.createAgent)({
+    const defaultAgent = (0, import_langchain57.createAgent)({
       model: params.model,
       tools,
       systemPrompt: buildStepSystemPrompt(false, params.prompt),
@@ -18816,7 +19615,7 @@ var WorkflowAgentGraphBuilder = class {
         console.log(`[WF BUILDER] resolveAgent: cacheKey=${key4.slice(0, 80)}... | cached=${agentCache.has(key4)}`);
         if (!agentCache.has(key4)) {
           console.log(`[WF BUILDER] creating ${isAsk ? "ask" : "agent"} with responseFormat`);
-          const agent = (0, import_langchain56.createAgent)({
+          const agent = (0, import_langchain57.createAgent)({
             model: params.model,
             tools,
             systemPrompt: buildStepSystemPrompt(isAsk, params.prompt),
@@ -18832,7 +19631,7 @@ var WorkflowAgentGraphBuilder = class {
         const key4 = "ask:default";
         if (!agentCache.has(key4)) {
           console.log(`[WF BUILDER] creating ask default agent`);
-          const agent = (0, import_langchain56.createAgent)({
+          const agent = (0, import_langchain57.createAgent)({
             model: params.model,
             tools,
             systemPrompt: buildStepSystemPrompt(true, params.prompt),
@@ -19351,6 +20150,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);
@@ -19495,7 +20310,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
@@ -19594,6 +20409,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
@@ -19644,6 +20613,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
 
 ---
 
@@ -19651,10 +20621,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
 
@@ -19690,10 +20661,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
 
@@ -19702,7 +20674,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
 
 ---
 
@@ -19736,6 +20709,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.
@@ -20795,8 +21770,8 @@ var InMemoryMenuStore = class {
 };
 
 // src/agent_lattice/agentArchitectTools.ts
-var import_zod47 = __toESM(require("zod"));
-var import_uuid7 = require("uuid");
+var import_zod48 = __toESM(require("zod"));
+var import_uuid8 = require("uuid");
 var import_protocols12 = require("@axiom-lattice/protocols");
 function getTenantId(exeConfig) {
   const runConfig = exeConfig?.configurable?.runConfig || {};
@@ -20825,7 +21800,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: import_zod47.default.object({})
+    schema: import_zod48.default.object({})
   },
   async (_input, exeConfig) => {
     try {
@@ -20852,8 +21827,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: import_zod47.default.object({
-      id: import_zod47.default.string().describe("The agent ID to retrieve")
+    schema: import_zod48.default.object({
+      id: import_zod48.default.string().describe("The agent ID to retrieve")
     })
   },
   async (input, exeConfig) => {
@@ -20870,24 +21845,24 @@ registerToolLattice(
     }
   }
 );
-var middlewareConfigSchema = import_zod47.default.object({
-  id: import_zod47.default.string(),
-  type: import_zod47.default.string(),
-  name: import_zod47.default.string(),
-  description: import_zod47.default.string(),
-  enabled: import_zod47.default.boolean(),
-  config: import_zod47.default.record(import_zod47.default.any()).optional()
+var middlewareConfigSchema = import_zod48.default.object({
+  id: import_zod48.default.string(),
+  type: import_zod48.default.string(),
+  name: import_zod48.default.string(),
+  description: import_zod48.default.string(),
+  enabled: import_zod48.default.boolean(),
+  config: import_zod48.default.record(import_zod48.default.any()).optional()
 });
-var createAgentSchema = import_zod47.default.object({
-  name: import_zod47.default.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: import_zod47.default.string().optional().describe("Short description"),
-  type: import_zod47.default.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: import_zod47.default.string().describe("System prompt for the agent"),
-  tools: import_zod47.default.array(import_zod47.default.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: import_zod47.default.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: import_zod47.default.array(import_zod47.default.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
-  internalSubAgents: import_zod47.default.array(import_zod47.default.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
-  modelKey: import_zod47.default.string().optional().describe("Model key to use")
+var createAgentSchema = import_zod48.default.object({
+  name: import_zod48.default.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: import_zod48.default.string().optional().describe("Short description"),
+  type: import_zod48.default.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: import_zod48.default.string().describe("System prompt for the agent"),
+  tools: import_zod48.default.array(import_zod48.default.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: import_zod48.default.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: import_zod48.default.array(import_zod48.default.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
+  internalSubAgents: import_zod48.default.array(import_zod48.default.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
+  modelKey: import_zod48.default.string().optional().describe("Model key to use")
 });
 registerToolLattice(
   "create_agent",
@@ -20925,14 +21900,14 @@ registerToolLattice(
     }
   }
 );
-var createWorkflowSchema = import_zod47.default.object({
-  name: import_zod47.default.string().describe("Display name for the workflow agent"),
-  description: import_zod47.default.string().optional().describe("Short description"),
-  skillLoaded: import_zod47.default.literal(true).describe("MUST be true. Set after loading the 'create-workflow' skill."),
-  yaml: import_zod47.default.string().describe("The YAML workflow definition in linear DSL format (steps execute top-to-bottom, use parallel: for concurrency)"),
-  tools: import_zod47.default.array(import_zod47.default.string()).optional().describe("Tool keys for the workflow agent"),
-  middleware: import_zod47.default.array(middlewareConfigSchema).optional().describe("Middleware configs"),
-  modelKey: import_zod47.default.string().optional().describe("Model key")
+var createWorkflowSchema = import_zod48.default.object({
+  name: import_zod48.default.string().describe("Display name for the workflow agent"),
+  description: import_zod48.default.string().optional().describe("Short description"),
+  skillLoaded: import_zod48.default.literal(true).describe("MUST be true. Set after loading the 'create-workflow' skill."),
+  yaml: import_zod48.default.string().describe("The YAML workflow definition in linear DSL format (steps execute top-to-bottom, use parallel: for concurrency)"),
+  tools: import_zod48.default.array(import_zod48.default.string()).optional().describe("Tool keys for the workflow agent"),
+  middleware: import_zod48.default.array(middlewareConfigSchema).optional().describe("Middleware configs"),
+  modelKey: import_zod48.default.string().optional().describe("Model key")
 });
 registerToolLattice(
   "create_workflow",
@@ -20981,8 +21956,8 @@ registerToolLattice(
   {
     name: "validate_workflow",
     description: "Validate a workflow agent's DSL for correctness by compiling it.",
-    schema: import_zod47.default.object({
-      id: import_zod47.default.string().describe("The workflow agent ID to validate")
+    schema: import_zod48.default.object({
+      id: import_zod48.default.string().describe("The workflow agent ID to validate")
     })
   },
   async (input, exeConfig) => {
@@ -21079,14 +22054,14 @@ registerToolLattice(
     }
   }
 );
-var updateWorkflowSchema = import_zod47.default.object({
-  id: import_zod47.default.string().describe("The workflow agent ID to update"),
-  name: import_zod47.default.string().optional().describe("New display name"),
-  description: import_zod47.default.string().optional().describe("New description"),
-  yaml: import_zod47.default.string().optional().describe("Replacement YAML workflow DSL. Omit to keep existing."),
-  tools: import_zod47.default.array(import_zod47.default.string()).optional().describe("Replacement tool keys"),
-  middleware: import_zod47.default.array(middlewareConfigSchema).optional().describe("Replacement middleware configs"),
-  modelKey: import_zod47.default.string().optional().describe("Replacement model key")
+var updateWorkflowSchema = import_zod48.default.object({
+  id: import_zod48.default.string().describe("The workflow agent ID to update"),
+  name: import_zod48.default.string().optional().describe("New display name"),
+  description: import_zod48.default.string().optional().describe("New description"),
+  yaml: import_zod48.default.string().optional().describe("Replacement YAML workflow DSL. Omit to keep existing."),
+  tools: import_zod48.default.array(import_zod48.default.string()).optional().describe("Replacement tool keys"),
+  middleware: import_zod48.default.array(middlewareConfigSchema).optional().describe("Replacement middleware configs"),
+  modelKey: import_zod48.default.string().optional().describe("Replacement model key")
 });
 registerToolLattice(
   "update_workflow",
@@ -21147,18 +22122,18 @@ registerToolLattice(
     }
   }
 );
-var updateAgentSchema = import_zod47.default.object({
-  id: import_zod47.default.string().describe("The agent ID to update"),
-  config: import_zod47.default.object({
-    name: import_zod47.default.string().optional().describe("New display name for the agent"),
-    description: import_zod47.default.string().optional().describe("New short description"),
-    type: import_zod47.default.enum(["react", "deep_agent"]).optional().describe("Agent type"),
-    prompt: import_zod47.default.string().optional().describe("New system prompt for the agent"),
-    tools: import_zod47.default.array(import_zod47.default.string()).optional().describe("Tool keys to assign to this agent. These are registered tool names (strings), NOT middleware objects."),
-    middleware: import_zod47.default.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: import_zod47.default.array(import_zod47.default.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
-    internalSubAgents: import_zod47.default.array(import_zod47.default.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
-    modelKey: import_zod47.default.string().optional().describe("Model key to use")
+var updateAgentSchema = import_zod48.default.object({
+  id: import_zod48.default.string().describe("The agent ID to update"),
+  config: import_zod48.default.object({
+    name: import_zod48.default.string().optional().describe("New display name for the agent"),
+    description: import_zod48.default.string().optional().describe("New short description"),
+    type: import_zod48.default.enum(["react", "deep_agent"]).optional().describe("Agent type"),
+    prompt: import_zod48.default.string().optional().describe("New system prompt for the agent"),
+    tools: import_zod48.default.array(import_zod48.default.string()).optional().describe("Tool keys to assign to this agent. These are registered tool names (strings), NOT middleware objects."),
+    middleware: import_zod48.default.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: import_zod48.default.array(import_zod48.default.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
+    internalSubAgents: import_zod48.default.array(import_zod48.default.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
+    modelKey: import_zod48.default.string().optional().describe("Model key to use")
   }).describe("Configuration fields to update. Only include the fields you want to change.")
 });
 registerToolLattice(
@@ -21196,8 +22171,8 @@ registerToolLattice(
   {
     name: "delete_agent",
     description: "Permanently delete an agent by its ID. This action cannot be undone.",
-    schema: import_zod47.default.object({
-      id: import_zod47.default.string().describe("The agent ID to delete")
+    schema: import_zod48.default.object({
+      id: import_zod48.default.string().describe("The agent ID to delete")
     })
   },
   async (input, exeConfig) => {
@@ -21223,7 +22198,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: import_zod47.default.object({})
+    schema: import_zod48.default.object({})
   },
   async (_input, _exeConfig) => {
     try {
@@ -21245,9 +22220,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: import_zod47.default.object({
-      id: import_zod47.default.string().describe("The agent ID to invoke"),
-      message: import_zod47.default.string().describe("The test message to send to the agent")
+    schema: import_zod48.default.object({
+      id: import_zod48.default.string().describe("The agent ID to invoke"),
+      message: import_zod48.default.string().describe("The test message to send to the agent")
     })
   },
   async (input, exeConfig) => {
@@ -21262,7 +22237,7 @@ registerToolLattice(
       if (!existing) {
         return JSON.stringify({ error: `Agent '${id}' not found` });
       }
-      const threadId = (0, import_uuid7.v4)();
+      const threadId = (0, import_uuid8.v4)();
       const agent = new Agent({
         tenant_id: tenantId2,
         assistant_id: id,
@@ -21283,7 +22258,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: import_zod47.default.object({})
+    schema: import_zod48.default.object({})
   },
   async () => {
     const metas = PluginRegistry.listMeta();
@@ -21295,8 +22270,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: import_zod47.default.object({
-      type: import_zod47.default.string().describe("\u63D2\u4EF6\u7C7B\u578B\u6807\u8BC6\uFF0C\u5982 'erp'\u3002\u4ECE list_middleware_types \u7684\u8FD4\u56DE\u4E2D\u83B7\u53D6")
+    schema: import_zod48.default.object({
+      type: import_zod48.default.string().describe("\u63D2\u4EF6\u7C7B\u578B\u6807\u8BC6\uFF0C\u5982 'erp'\u3002\u4ECE list_middleware_types \u7684\u8FD4\u56DE\u4E2D\u83B7\u53D6")
     }),
     needUserApprove: false
   },
@@ -21877,6 +22852,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 } : {};
@@ -22075,6 +23064,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);
@@ -25254,8 +26244,8 @@ function clearEvalRunService() {
 }
 
 // src/eval_lattice/LatticeEval.ts
-var import_messages5 = require("@langchain/core/messages");
-var import_uuid8 = require("uuid");
+var import_messages6 = require("@langchain/core/messages");
+var import_uuid9 = require("uuid");
 var _LatticeEval = class _LatticeEval {
   constructor(config = {}) {
     this.inMemoryLogs = [];
@@ -25395,7 +26385,7 @@ var _LatticeEval = class _LatticeEval {
   }
   async evaluateCase(evalCase) {
     const startedAt = Date.now();
-    const threadId = `${evalCase.caseId}||${(0, import_uuid8.v4)()}`;
+    const threadId = `${evalCase.caseId}||${(0, import_uuid9.v4)()}`;
     this.inMemoryLogs = [];
     this.lastThreadId = threadId;
     this.lastJudgeThreadId = void 0;
@@ -25537,7 +26527,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 = (0, import_uuid8.v4)();
+    const judgeThreadId = (0, import_uuid9.v4)();
     this.lastJudgeThreadId = judgeThreadId;
     const judgeAgentKey = this.config.judge_agent_key || "LatticeTest";
     const judgeTenantId = this.config.tenant_id || "default";
@@ -25545,7 +26535,7 @@ ${rubricsSection}
     const judgeAgent = await getAgentClient(judgeTenantId, judgeAgentKey);
     const testResponse = await judgeAgent.invoke(
       {
-        messages: [new import_messages5.HumanMessage(testPrompt)]
+        messages: [new import_messages6.HumanMessage(testPrompt)]
       },
       {
         configurable: {
@@ -26137,15 +27127,15 @@ function clearEncryptionKeyCache() {
 }
 
 // src/middlewares/skillMiddleware.ts
-var import_langchain59 = require("langchain");
+var import_langchain60 = require("langchain");
 
 // src/tool_lattice/skill/load_skills.ts
-var import_zod48 = __toESM(require("zod"));
-var import_langchain57 = require("langchain");
-
-// src/tool_lattice/skill/load_skill_content.ts
 var import_zod49 = __toESM(require("zod"));
 var import_langchain58 = require("langchain");
+
+// src/tool_lattice/skill/load_skill_content.ts
+var import_zod50 = __toESM(require("zod"));
+var import_langchain59 = require("langchain");
 var LOAD_SKILL_CONTENT_DESCRIPTION = `
 Execute a skill within the main conversation
 
@@ -26183,7 +27173,7 @@ function getSandboxFromExeConfig(_exe_config) {
   });
 }
 var createLoadSkillContentTool = (pluginSkillContents) => {
-  return (0, import_langchain58.tool)(
+  return (0, import_langchain59.tool)(
     async (input, _exe_config) => {
       try {
         if (pluginSkillContents?.[input.skill_name]) {
@@ -26232,8 +27222,8 @@ var createLoadSkillContentTool = (pluginSkillContents) => {
     {
       name: "skill",
       description: LOAD_SKILL_CONTENT_DESCRIPTION,
-      schema: import_zod49.default.object({
-        skill_name: import_zod49.default.string().describe("The name of the skill to load")
+      schema: import_zod50.default.object({
+        skill_name: import_zod50.default.string().describe("The name of the skill to load")
       })
     }
   );
@@ -26247,7 +27237,7 @@ function createSkillMiddleware(params = {}) {
   } = params;
   const skills = params.skills;
   let latestSkills = [];
-  return (0, import_langchain59.createMiddleware)({
+  return (0, import_langchain60.createMiddleware)({
     name: "skillMiddleware",
     contextSchema,
     tools: [
@@ -26379,17 +27369,17 @@ var skillPlugin = {
 };
 
 // src/middlewares/collectionMiddleware.ts
-var import_langchain70 = require("langchain");
+var import_langchain71 = require("langchain");
 
 // src/tool_lattice/collection/list_collections.ts
-var import_zod50 = __toESM(require("zod"));
-var import_langchain60 = require("langchain");
+var import_zod51 = __toESM(require("zod"));
+var import_langchain61 = require("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 (0, import_langchain60.tool)(
+  return (0, import_langchain61.tool)(
     async (_input, _exeConfig) => {
       try {
         const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -26423,23 +27413,23 @@ var createListCollectionsTool = ({
     {
       name: "list_collections",
       description: LIST_COLLECTIONS_DESCRIPTION,
-      schema: import_zod50.default.object({})
+      schema: import_zod51.default.object({})
     }
   );
 };
 
 // src/tool_lattice/collection/search_collection.ts
-var import_zod51 = __toESM(require("zod"));
-var import_langchain61 = require("langchain");
+var import_zod52 = __toESM(require("zod"));
+var import_langchain62 = require("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 = import_zod51.default.object({
-  collection: import_zod51.default.string().describe("The collection name to search in"),
-  query: import_zod51.default.string().describe("The search query text"),
-  filter: import_zod51.default.record(import_zod51.default.unknown()).optional().describe("Metadata filter conditions"),
-  top_k: import_zod51.default.number().optional().default(5).describe("Number of results to return")
+var searchSchema = import_zod52.default.object({
+  collection: import_zod52.default.string().describe("The collection name to search in"),
+  query: import_zod52.default.string().describe("The search query text"),
+  filter: import_zod52.default.record(import_zod52.default.unknown()).optional().describe("Metadata filter conditions"),
+  top_k: import_zod52.default.number().optional().default(5).describe("Number of results to return")
 });
 var createSearchCollectionTool = () => {
-  return (0, import_langchain61.tool)(
+  return (0, import_langchain62.tool)(
     async (input, _exeConfig) => {
       try {
         const { collection, query, filter: filter2, top_k } = input;
@@ -26489,10 +27479,10 @@ var createSearchCollectionTool = () => {
 };
 
 // src/tool_lattice/collection/get_collection.ts
-var import_zod52 = __toESM(require("zod"));
-var import_langchain62 = require("langchain");
+var import_zod53 = __toESM(require("zod"));
+var import_langchain63 = require("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 = () => (0, import_langchain62.tool)(
+var createGetCollectionTool = () => (0, import_langchain63.tool)(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -26515,24 +27505,24 @@ Embedding: ${c.embeddingKey}${fieldsDesc}`;
       return `Error: ${error.message}`;
     }
   },
-  { name: "get_collection", description: GET_COLLECTION_DESCRIPTION, schema: import_zod52.default.object({ name: import_zod52.default.string().describe("Collection name") }) }
+  { name: "get_collection", description: GET_COLLECTION_DESCRIPTION, schema: import_zod53.default.object({ name: import_zod53.default.string().describe("Collection name") }) }
 );
 
 // src/tool_lattice/collection/create_collection.ts
-var import_zod53 = __toESM(require("zod"));
-var import_langchain63 = require("langchain");
-var createSchema = import_zod53.default.object({
-  name: import_zod53.default.string().describe("Collection name (lowercase, underscores only)"),
-  label: import_zod53.default.string().describe("Display name"),
-  embeddingKey: import_zod53.default.string().describe("Embedding model key"),
-  fields: import_zod53.default.array(import_zod53.default.object({
-    key: import_zod53.default.string().describe("Field key name"),
-    type: import_zod53.default.enum(["string", "number", "enum"]).describe("Field data type"),
-    enumValues: import_zod53.default.array(import_zod53.default.string()).optional().describe("Valid values for enum type"),
-    required: import_zod53.default.boolean().optional().default(false).describe("Whether field is required")
+var import_zod54 = __toESM(require("zod"));
+var import_langchain64 = require("langchain");
+var createSchema = import_zod54.default.object({
+  name: import_zod54.default.string().describe("Collection name (lowercase, underscores only)"),
+  label: import_zod54.default.string().describe("Display name"),
+  embeddingKey: import_zod54.default.string().describe("Embedding model key"),
+  fields: import_zod54.default.array(import_zod54.default.object({
+    key: import_zod54.default.string().describe("Field key name"),
+    type: import_zod54.default.enum(["string", "number", "enum"]).describe("Field data type"),
+    enumValues: import_zod54.default.array(import_zod54.default.string()).optional().describe("Valid values for enum type"),
+    required: import_zod54.default.boolean().optional().default(false).describe("Whether field is required")
   })).optional().describe("Custom field definitions for entries in this collection")
 });
-var createCreateCollectionTool = () => (0, import_langchain63.tool)(
+var createCreateCollectionTool = () => (0, import_langchain64.tool)(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -26557,20 +27547,20 @@ var createCreateCollectionTool = () => (0, import_langchain63.tool)(
 );
 
 // src/tool_lattice/collection/update_collection.ts
-var import_zod54 = __toESM(require("zod"));
-var import_langchain64 = require("langchain");
-var schema = import_zod54.default.object({
-  name: import_zod54.default.string().describe("Collection name"),
-  label: import_zod54.default.string().optional().describe("New display name"),
-  embeddingKey: import_zod54.default.string().optional().describe("New embedding model key"),
-  fields: import_zod54.default.array(import_zod54.default.object({
-    key: import_zod54.default.string().describe("Field key name"),
-    type: import_zod54.default.enum(["string", "number", "enum"]).describe("Field data type"),
-    enumValues: import_zod54.default.array(import_zod54.default.string()).optional().describe("Valid values for enum type"),
-    required: import_zod54.default.boolean().optional().default(false).describe("Whether field is required")
+var import_zod55 = __toESM(require("zod"));
+var import_langchain65 = require("langchain");
+var schema = import_zod55.default.object({
+  name: import_zod55.default.string().describe("Collection name"),
+  label: import_zod55.default.string().optional().describe("New display name"),
+  embeddingKey: import_zod55.default.string().optional().describe("New embedding model key"),
+  fields: import_zod55.default.array(import_zod55.default.object({
+    key: import_zod55.default.string().describe("Field key name"),
+    type: import_zod55.default.enum(["string", "number", "enum"]).describe("Field data type"),
+    enumValues: import_zod55.default.array(import_zod55.default.string()).optional().describe("Valid values for enum type"),
+    required: import_zod55.default.boolean().optional().default(false).describe("Whether field is required")
   })).optional().describe("Custom field definitions for entries (replaces existing schema)")
 });
-var createUpdateCollectionTool = () => (0, import_langchain64.tool)(
+var createUpdateCollectionTool = () => (0, import_langchain65.tool)(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -26589,9 +27579,9 @@ var createUpdateCollectionTool = () => (0, import_langchain64.tool)(
 );
 
 // src/tool_lattice/collection/delete_collection.ts
-var import_zod55 = __toESM(require("zod"));
-var import_langchain65 = require("langchain");
-var createDeleteCollectionTool = () => (0, import_langchain65.tool)(
+var import_zod56 = __toESM(require("zod"));
+var import_langchain66 = require("langchain");
+var createDeleteCollectionTool = () => (0, import_langchain66.tool)(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -26601,19 +27591,19 @@ var createDeleteCollectionTool = () => (0, import_langchain65.tool)(
       return `Error: ${e.message}`;
     }
   },
-  { name: "delete_collection", description: `Delete a collection and all its entries. This cannot be undone.`, schema: import_zod55.default.object({ name: import_zod55.default.string().describe("Collection name") }) }
+  { name: "delete_collection", description: `Delete a collection and all its entries. This cannot be undone.`, schema: import_zod56.default.object({ name: import_zod56.default.string().describe("Collection name") }) }
 );
 
 // src/tool_lattice/collection/list_entries.ts
-var import_zod56 = __toESM(require("zod"));
-var import_langchain66 = require("langchain");
-var schema2 = import_zod56.default.object({
-  collection: import_zod56.default.string().describe("Collection name")
+var import_zod57 = __toESM(require("zod"));
+var import_langchain67 = require("langchain");
+var schema2 = import_zod57.default.object({
+  collection: import_zod57.default.string().describe("Collection name")
 });
 function buildKey2(tenantId2, name) {
   return `${tenantId2}:${name}`;
 }
-var createListEntriesTool = () => (0, import_langchain66.tool)(
+var createListEntriesTool = () => (0, import_langchain67.tool)(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -26640,24 +27630,24 @@ var createListEntriesTool = () => (0, import_langchain66.tool)(
 );
 
 // src/tool_lattice/collection/add_entry.ts
-var import_zod57 = __toESM(require("zod"));
-var import_langchain67 = require("langchain");
+var import_zod58 = __toESM(require("zod"));
+var import_langchain68 = require("langchain");
 var import_documents = require("@langchain/core/documents");
-var import_uuid9 = require("uuid");
-var schema3 = import_zod57.default.object({
-  collection: import_zod57.default.string().describe("Collection name"),
-  content: import_zod57.default.string().describe("Entry content text"),
-  metadata: import_zod57.default.record(import_zod57.default.unknown()).optional().describe("Metadata fields matching the collection schema")
+var import_uuid10 = require("uuid");
+var schema3 = import_zod58.default.object({
+  collection: import_zod58.default.string().describe("Collection name"),
+  content: import_zod58.default.string().describe("Entry content text"),
+  metadata: import_zod58.default.record(import_zod58.default.unknown()).optional().describe("Metadata fields matching the collection schema")
 });
 function key(t, n) {
   return `${t}:${n}`;
 }
-var createAddEntryTool = () => (0, import_langchain67.tool)(
+var createAddEntryTool = () => (0, import_langchain68.tool)(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
       const vs = vectorStoreLatticeManager.getVectorStoreClient(key(tenantId2, input.collection));
-      const id = (0, import_uuid9.v4)();
+      const id = (0, import_uuid10.v4)();
       await vs.addDocuments([new import_documents.Document({
         pageContent: input.content,
         metadata: { _id: id, _created_at: (/* @__PURE__ */ new Date()).toISOString(), ...input.metadata || {} }
@@ -26671,18 +27661,18 @@ var createAddEntryTool = () => (0, import_langchain67.tool)(
 );
 
 // src/tool_lattice/collection/update_entry.ts
-var import_zod58 = __toESM(require("zod"));
-var import_langchain68 = require("langchain");
-var schema4 = import_zod58.default.object({
-  collection: import_zod58.default.string().describe("Collection name"),
-  entryId: import_zod58.default.string().describe("Entry ID to update"),
-  content: import_zod58.default.string().optional().describe("New content"),
-  metadata: import_zod58.default.record(import_zod58.default.unknown()).optional().describe("New metadata")
+var import_zod59 = __toESM(require("zod"));
+var import_langchain69 = require("langchain");
+var schema4 = import_zod59.default.object({
+  collection: import_zod59.default.string().describe("Collection name"),
+  entryId: import_zod59.default.string().describe("Entry ID to update"),
+  content: import_zod59.default.string().optional().describe("New content"),
+  metadata: import_zod59.default.record(import_zod59.default.unknown()).optional().describe("New metadata")
 });
 function key2(t, n) {
   return `${t}:${n}`;
 }
-var createUpdateEntryTool = () => (0, import_langchain68.tool)(
+var createUpdateEntryTool = () => (0, import_langchain69.tool)(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -26701,16 +27691,16 @@ var createUpdateEntryTool = () => (0, import_langchain68.tool)(
 );
 
 // src/tool_lattice/collection/delete_entry.ts
-var import_zod59 = __toESM(require("zod"));
-var import_langchain69 = require("langchain");
-var schema5 = import_zod59.default.object({
-  collection: import_zod59.default.string().describe("Collection name"),
-  entryId: import_zod59.default.string().describe("Entry ID to delete")
+var import_zod60 = __toESM(require("zod"));
+var import_langchain70 = require("langchain");
+var schema5 = import_zod60.default.object({
+  collection: import_zod60.default.string().describe("Collection name"),
+  entryId: import_zod60.default.string().describe("Entry ID to delete")
 });
 function key3(t, n) {
   return `${t}:${n}`;
 }
-var createDeleteEntryTool = () => (0, import_langchain69.tool)(
+var createDeleteEntryTool = () => (0, import_langchain70.tool)(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -26728,7 +27718,7 @@ var createDeleteEntryTool = () => (0, import_langchain69.tool)(
 function createCollectionMiddleware(params) {
   const { collectionKeys, connectAll } = params;
   if (!connectAll && (!collectionKeys || collectionKeys.length === 0)) {
-    return (0, import_langchain70.createMiddleware)({
+    return (0, import_langchain71.createMiddleware)({
       name: "collectionMiddleware",
       contextSchema,
       tools: [
@@ -26738,7 +27728,7 @@ function createCollectionMiddleware(params) {
     });
   }
   const listToolParams = { collectionKeys, connectAll };
-  return (0, import_langchain70.createMiddleware)({
+  return (0, import_langchain71.createMiddleware)({
     name: "collectionMiddleware",
     contextSchema,
     tools: [
@@ -26799,24 +27789,24 @@ var collectionPlugin = {
 };
 
 // src/middlewares/askUserClarifyMiddleware.ts
-var import_langchain72 = require("langchain");
+var import_langchain73 = require("langchain");
 var import_langgraph14 = require("@langchain/langgraph");
 
 // src/tool_lattice/ask_user_to_clarify/index.ts
-var import_langchain71 = require("langchain");
-var import_zod60 = __toESM(require("zod"));
-var questionSchema = import_zod60.default.object({
-  question: import_zod60.default.string().describe("The question text to ask the user"),
-  options: import_zod60.default.array(import_zod60.default.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: import_zod60.default.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: import_zod60.default.boolean().optional().default(false).describe("Whether this question must be answered"),
-  allowOther: import_zod60.default.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 import_langchain72 = require("langchain");
+var import_zod61 = __toESM(require("zod"));
+var questionSchema = import_zod61.default.object({
+  question: import_zod61.default.string().describe("The question text to ask the user"),
+  options: import_zod61.default.array(import_zod61.default.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: import_zod61.default.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: import_zod61.default.boolean().optional().default(false).describe("Whether this question must be answered"),
+  allowOther: import_zod61.default.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 = import_zod60.default.object({
-  questions: import_zod60.default.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 = import_zod61.default.object({
+  questions: import_zod61.default.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 (0, import_langchain71.tool)(
+  return (0, import_langchain72.tool)(
     async (input) => {
       return JSON.stringify(input);
     },
@@ -26830,7 +27820,7 @@ function createAskUserToClarifyTool() {
 
 // src/middlewares/askUserClarifyMiddleware.ts
 function createAskUserClarifyMiddleware() {
-  return (0, import_langchain72.createMiddleware)({
+  return (0, import_langchain73.createMiddleware)({
     name: "AskUserClarifyMiddleware",
     tools: [createAskUserToClarifyTool()],
     wrapToolCall: async (request, handler) => {
@@ -26844,7 +27834,7 @@ function createAskUserClarifyMiddleware() {
             throw error;
           }
           console.error(`Error executing tool "${toolName}":`, error);
-          return new import_langchain72.ToolMessage({
+          return new import_langchain73.ToolMessage({
             content: `Error executing tool: ${error instanceof Error ? error.message : "Unknown error"}`,
             tool_call_id: toolCall?.id,
             name: toolName
@@ -26853,7 +27843,7 @@ function createAskUserClarifyMiddleware() {
       }
       const parsed = inputSchema.safeParse(toolCall?.args);
       if (!parsed.success) {
-        return new import_langchain72.ToolMessage({
+        return new import_langchain73.ToolMessage({
           content: `Invalid clarify tool arguments: ${parsed.error.message}`,
           tool_call_id: toolCall?.id,
           name: toolName
@@ -26873,7 +27863,7 @@ function createAskUserClarifyMiddleware() {
       const result = await (0, import_langgraph14.interrupt)(md);
       const response = result.data;
       if (!response?.answers || response.answers.length === 0) {
-        return new import_langchain72.ToolMessage({
+        return new import_langchain73.ToolMessage({
           content: "No clarification questions were answered.",
           tool_call_id: toolCall?.id,
           name: toolName
@@ -26883,7 +27873,7 @@ function createAskUserClarifyMiddleware() {
         (answer) => (answer.selectedOptions?.length ?? 0) > 0 || answer.otherText && answer.otherText.trim() !== "" || answer.filePath && answer.filePath.trim() !== ""
       );
       if (answeredQuestions.length === 0) {
-        return new import_langchain72.ToolMessage({
+        return new import_langchain73.ToolMessage({
           content: "No clarification questions were answered.",
           tool_call_id: toolCall?.id,
           name: toolName
@@ -26913,7 +27903,7 @@ function createAskUserClarifyMiddleware() {
         }
         lines.push("");
       }
-      return new import_langchain72.ToolMessage({
+      return new import_langchain73.ToolMessage({
         content: lines.join("\n"),
         tool_call_id: toolCall?.id,
         name: toolName
@@ -26938,11 +27928,11 @@ var askUserClarifyPlugin = {
 };
 
 // src/middlewares/widgetMiddleware.ts
-var import_langchain75 = require("langchain");
+var import_langchain76 = require("langchain");
 
 // src/tool_lattice/widget/loadGuidelines.ts
-var import_langchain73 = require("langchain");
-var import_zod61 = require("zod");
+var import_langchain74 = require("langchain");
+var import_zod62 = require("zod");
 
 // src/middlewares/guidelines/index.ts
 var CORE = `# Imagine \u2014 Visual Creation Suite
@@ -27733,13 +28723,13 @@ function getGuidelines(modules) {
 var AVAILABLE_MODULES = Object.keys(MODULE_SECTIONS);
 
 // src/tool_lattice/widget/loadGuidelines.ts
-var LoadGuidelinesInputSchema = import_zod61.z.object({
-  modules: import_zod61.z.array(import_zod61.z.string()).describe(
+var LoadGuidelinesInputSchema = import_zod62.z.object({
+  modules: import_zod62.z.array(import_zod62.z.string()).describe(
     "Which design modules to load. Choose all that apply. Available modules: [" + AVAILABLE_MODULES.join(",") + "]"
   )
 });
 function createLoadGuidelinesTool() {
-  return (0, import_langchain73.tool)(
+  return (0, import_langchain74.tool)(
     async (input) => {
       const result = getGuidelines(input.modules);
       return result;
@@ -27753,8 +28743,8 @@ function createLoadGuidelinesTool() {
 }
 
 // src/tool_lattice/widget/showWidget.ts
-var import_langchain74 = require("langchain");
-var import_zod62 = require("zod");
+var import_langchain75 = require("langchain");
+var import_zod63 = require("zod");
 function containsForbiddenTags(code) {
   const forbiddenPatterns = [
     /<!DOCTYPE/i,
@@ -27776,20 +28766,20 @@ function validateWidgetCode(code) {
   }
   return { valid: true };
 }
-var ShowWidgetInputSchema = import_zod62.z.object({
-  i_have_seen_guidelines: import_zod62.z.boolean().describe(
+var ShowWidgetInputSchema = import_zod63.z.object({
+  i_have_seen_guidelines: import_zod63.z.boolean().describe(
     "Must be true. Confirm you have called load_guidelines first."
   ),
-  title: import_zod62.z.string().describe("Title displayed above the widget"),
-  loading_messages: import_zod62.z.array(import_zod62.z.string()).optional().describe(
+  title: import_zod63.z.string().describe("Title displayed above the widget"),
+  loading_messages: import_zod63.z.array(import_zod63.z.string()).optional().describe(
     "1-4 short strings shown while the widget renders"
   ),
-  widget_code: import_zod62.z.string().describe(
+  widget_code: import_zod63.z.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 (0, import_langchain74.tool)(
+  return (0, import_langchain75.tool)(
     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.";
@@ -27820,7 +28810,7 @@ function createWidgetMiddleware() {
     createLoadGuidelinesTool(),
     createShowWidgetTool()
   ];
-  return (0, import_langchain75.createMiddleware)({
+  return (0, import_langchain76.createMiddleware)({
     name: "widgetMiddleware",
     contextSchema,
     tools
@@ -27842,157 +28832,10 @@ var widgetPlugin = {
   middleware: () => createWidgetMiddleware()
 };
 
-// src/middlewares/taskMiddleware.ts
-var import_langchain76 = require("langchain");
-var import_zod63 = require("zod");
-function getRunConfig2(config) {
-  const c = config;
-  return c?.configurable?.runConfig ?? {};
-}
-function getTaskStore() {
-  return getStoreLattice("default", "task").store;
-}
-var manageTaskSchema = import_zod63.z.object({
-  action: import_zod63.z.enum(["create", "list", "update", "delete", "complete"]).describe("\u64CD\u4F5C\u7C7B\u578B"),
-  id: import_zod63.z.string().optional().describe("\u4EFB\u52A1 ID (update/delete/complete \u5FC5\u586B)"),
-  title: import_zod63.z.string().optional().describe("\u4EFB\u52A1\u6807\u9898 (create \u5FC5\u586B)"),
-  description: import_zod63.z.string().optional().describe("\u4EFB\u52A1\u63CF\u8FF0"),
-  priority: import_zod63.z.enum(["low", "medium", "high"]).optional().describe("\u4F18\u5148\u7EA7"),
-  status: import_zod63.z.enum(["pending", "in_progress", "completed", "cancelled"]).optional().describe("\u72B6\u6001"),
-  dueDate: import_zod63.z.string().optional().describe("\u622A\u6B62\u65E5\u671F (ISO 8601)"),
-  metadata: import_zod63.z.record(import_zod63.z.unknown()).optional().describe("\u7ED3\u6784\u5316\u5143\u6570\u636E (projectId, module \u7B49)"),
-  parentId: import_zod63.z.string().optional().describe("\u7236\u4EFB\u52A1 ID (\u5B50\u4EFB\u52A1\u5173\u8054)"),
-  sourceId: import_zod63.z.string().optional().describe("\u6765\u6E90\u4F1A\u8BDD/thread ID"),
-  context: import_zod63.z.record(import_zod63.z.unknown()).optional().describe("\u9644\u52A0\u4E0A\u4E0B\u6587"),
-  ownerType: import_zod63.z.enum(["user", "agent"]).optional().describe("\u6240\u6709\u8005\u7C7B\u578B\uFF0C\u4E0D\u4F20\u9ED8\u8BA4\u4E3A user"),
-  ownerId: import_zod63.z.string().optional().describe("\u6240\u6709\u8005 ID\uFF0C\u4E0D\u4F20\u81EA\u52A8\u53D6\u5F53\u524D\u7528\u6237/Agent")
-});
-function createTaskMiddleware() {
-  return (0, import_langchain76.createMiddleware)({
-    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: [
-      (0, import_langchain76.tool)(
-        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
 var import_langchain77 = require("langchain");
 var import_zod64 = require("zod");
-var import_uuid10 = require("uuid");
+var import_uuid11 = require("uuid");
 
 // src/middlewares/evalSkills.ts
 var EVAL_SKILLS = {
@@ -28206,7 +29049,7 @@ function createManageEvalTool() {
         let data;
         switch (input.action) {
           case "create_project":
-            data = await store.createProject(tid, (0, import_uuid10.v4)(), {
+            data = await store.createProject(tid, (0, import_uuid11.v4)(), {
               name: input.name,
               description: input.description,
               judgeModelConfig: { modelKey: input.judgeModelKey },
@@ -28230,7 +29073,7 @@ function createManageEvalTool() {
             break;
           }
           case "create_suite":
-            data = await store.createSuite(tid, input.projectId, (0, import_uuid10.v4)(), { name: input.name });
+            data = await store.createSuite(tid, input.projectId, (0, import_uuid11.v4)(), { name: input.name });
             break;
           case "update_suite":
             data = await store.updateSuite(tid, input.suiteId, { name: input.name });
@@ -28240,7 +29083,7 @@ function createManageEvalTool() {
             data = true;
             break;
           case "create_case":
-            data = await store.createCase(tid, input.suiteId, (0, import_uuid10.v4)(), {
+            data = await store.createCase(tid, input.suiteId, (0, import_uuid11.v4)(), {
               inputMessage: input.inputMessage,
               inputFiles: input.inputFiles,
               steps: input.steps,
@@ -28859,6 +29702,8 @@ registerBuiltinPlugins();
   QueueMode,
   RemoteSandboxInstance,
   RemoteSandboxProvider,
+  STTModelLattice,
+  STTModelLatticeManager,
   SandboxFilesystem,
   SandboxLatticeManager,
   SandboxSkillStore,
@@ -28964,6 +29809,9 @@ registerBuiltinPlugins();
   getNextCronTime,
   getOrCreateCollectionVectorStore,
   getQueueLattice,
+  getSTTClient,
+  getSTTClientWithTenant,
+  getSTTModelLattice,
   getSandBoxManager,
   getScheduleLattice,
   getStoreLattice,
@@ -29007,6 +29855,7 @@ registerBuiltinPlugins();
   registerLoggerLattice,
   registerModelLattice,
   registerQueueLattice,
+  registerSTTModelLattice,
   registerSandboxProviderType,
   registerScheduleLattice,
   registerStoreLattice,
@@ -29028,6 +29877,7 @@ registerBuiltinPlugins();
   skillLatticeManager,
   sqlDatabaseManager,
   storeLatticeManager,
+  sttModelLatticeManager,
   toJsonSchema,
   toSafeStateExpr,
   toolLatticeManager,