@axiom-lattice/core 2.1.56 → 2.1.58

package/dist/index.mjs

@@ -648,11 +648,11 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
    * @param key Lattice键名
    * @param tool 已有的StructuredTool实例
    */
-  registerExistingTool(key, tool50) {
+  registerExistingTool(key, tool51) {
     const config = {
-      name: tool50.name,
-      description: tool50.description,
-      schema: tool50.schema,
+      name: tool51.name,
+      description: tool51.description,
+      schema: tool51.schema,
       // StructuredTool的schema已经是Zod兼容的
       needUserApprove: false
       // MCP工具默认不需要用户批准
@@ -660,7 +660,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
     const toolLattice = {
       key,
       config,
-      client: tool50
+      client: tool51
     };
     this.register(key, toolLattice);
   }
@@ -686,7 +686,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
 };
 var toolLatticeManager = ToolLatticeManager.getInstance();
 var registerToolLattice = (key, config, executor) => toolLatticeManager.registerLattice(key, config, executor);
-var registerExistingTool = (key, tool50) => toolLatticeManager.registerExistingTool(key, tool50);
+var registerExistingTool = (key, tool51) => toolLatticeManager.registerExistingTool(key, tool51);
 var getToolLattice = (key) => toolLatticeManager.getToolLattice(key);
 var getToolDefinition = (key) => toolLatticeManager.getToolDefinition(key);
 var getToolClient = (key) => toolLatticeManager.getToolClient(key);
@@ -1120,14 +1120,14 @@ import z3 from "zod";
 import { tool as tool2 } from "langchain";
 
 // src/tool_lattice/sql/utils.ts
-function getTenantIdFromConfig(exeConfig, getTenantId) {
+function getTenantIdFromConfig(exeConfig, getTenantId2) {
   const runConfig = exeConfig?.configurable?.runConfig || {};
-  return runConfig.tenantId || (getTenantId ? getTenantId() : "default");
+  return runConfig.tenantId || (getTenantId2 ? getTenantId2() : "default");
 }
 
 // src/tool_lattice/sql/list_tables_sql.ts
 var LIST_TABLES_SQL_DESCRIPTION = `List all tables in the connected SQL database. Returns a comma-separated list of table names. Use this tool first to understand what tables are available before querying the database.`;
-var createListTablesSqlTool = ({ databaseKeys, databaseDescriptions, getTenantId }) => {
+var createListTablesSqlTool = ({ databaseKeys, databaseDescriptions, getTenantId: getTenantId2 }) => {
   const availableDbsText = databaseKeys.length > 0 ? `
 
 Available databases:
@@ -1137,7 +1137,7 @@ ${databaseKeys.map(
   return tool2(
     async ({ databaseKey }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId2);
         if (!databaseKey) {
           return "Error: databaseKey parameter is required. Available databases: " + databaseKeys.join(", ");
         }
@@ -1171,7 +1171,7 @@ ${databaseKeys.map(
 import z4 from "zod";
 import { tool as tool3 } from "langchain";
 var INFO_SQL_DESCRIPTION = `Get detailed schema information for specified tables, including column names, types, constraints (primary keys, foreign keys), and sample rows. Input should be a comma-separated list of table names.`;
-var createInfoSqlTool = ({ databaseKeys, databaseDescriptions, getTenantId }) => {
+var createInfoSqlTool = ({ databaseKeys, databaseDescriptions, getTenantId: getTenantId2 }) => {
   const availableDbsText = databaseKeys.length > 0 ? `
 
 Available databases:
@@ -1184,7 +1184,7 @@ ${databaseKeys.map(
       databaseKey
     }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId2);
         if (!databaseKey) {
           return "Error: databaseKey parameter is required. Available databases: " + databaseKeys.join(", ");
         }
@@ -1303,7 +1303,7 @@ function checkDangerousOperations(query) {
   }
   return warnings;
 }
-var createQueryCheckerSqlTool = ({ databaseKeys, databaseDescriptions, getTenantId }) => {
+var createQueryCheckerSqlTool = ({ databaseKeys, databaseDescriptions, getTenantId: getTenantId2 }) => {
   const availableDbsText = databaseKeys.length > 0 ? `
 
 Available databases:
@@ -1316,7 +1316,7 @@ ${databaseKeys.map(
       databaseKey
     }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId2);
         const trimmedQuery = query.trim();
         if (!trimmedQuery) {
           return "Error: Empty query provided. Please provide a SQL query to check.";
@@ -1425,7 +1425,7 @@ function formatQueryResult(rows, fields) {
 Total rows: ${rows.length}`);
   return lines.join("\n");
 }
-var createQuerySqlTool = ({ databaseKeys, databaseDescriptions, getTenantId }) => {
+var createQuerySqlTool = ({ databaseKeys, databaseDescriptions, getTenantId: getTenantId2 }) => {
   const availableDbsText = databaseKeys.length > 0 ? `
 
 Available databases:
@@ -1438,7 +1438,7 @@ ${databaseKeys.map(
       databaseKey
     }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId2);
         if (!databaseKey) {
           return "Error: databaseKey parameter is required. Available databases: " + databaseKeys.join(", ");
         }
@@ -1470,9 +1470,9 @@ ${databaseKeys.map(
 };
 
 // src/tool_lattice/metrics/utils.ts
-function getTenantIdFromConfig2(exeConfig, getTenantId) {
+function getTenantIdFromConfig2(exeConfig, getTenantId2) {
   const runConfig = exeConfig?.configurable?.runConfig || {};
-  return runConfig.tenantId || (getTenantId ? getTenantId() : "default");
+  return runConfig.tenantId || (getTenantId2 ? getTenantId2() : "default");
 }
 function filterServerKeysByTenant(serverKeys, tenantId, manager = metricsServerManager) {
   return serverKeys.filter((key) => {
@@ -2324,7 +2324,7 @@ var metricsServerManager = MetricsServerManager.getInstance();
 import z7 from "zod";
 import { tool as tool6 } from "langchain";
 var LIST_METRICS_SERVERS_DESCRIPTION = `List all registered metrics servers. Returns a list of available metrics servers with their keys and types. Use this tool first to understand what metrics servers are available.`;
-var createListMetricsServersTool = ({ serverKeys, serverDescriptions, getTenantId }) => {
+var createListMetricsServersTool = ({ serverKeys, serverDescriptions, getTenantId: getTenantId2 }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -2334,7 +2334,7 @@ ${serverKeys.map(
   return tool6(
     async (_input, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId2);
         const servers = metricsServerManager.getServerKeys(tenantId);
         if (servers.length === 0) {
           return "No metrics servers registered.";
@@ -2361,7 +2361,7 @@ ${lines.join("\n")}`;
 import z8 from "zod";
 import { tool as tool7 } from "langchain";
 var LIST_METRICS_DATASOURCES_DESCRIPTION = `List all available datasources from all configured metrics servers. Returns a table with Server Key, DataSource ID, and DataSource Name. Use this tool first to discover what datasources are available before querying metrics.`;
-var createListMetricsDataSourcesTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
+var createListMetricsDataSourcesTool = ({ serverKeys, serverDescriptions, getTenantId: getTenantId2, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Configured metrics servers:
@@ -2371,7 +2371,7 @@ ${serverKeys.map(
   return tool7(
     async (_input, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId2);
         let effectiveServerKeys = serverKeys;
         if (connectAll) {
           effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
@@ -2477,7 +2477,7 @@ Response Fields Reference
 
 Next Step
 After finding relevant metrics, call query_metric_definition with the metricName to get detailed metadata including time dimensions and supported filters.`;
-var createQueryMetricsListTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
+var createQueryMetricsListTool = ({ serverKeys, serverDescriptions, getTenantId: getTenantId2, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -2490,7 +2490,7 @@ ${serverKeys.map(
       datasourceIds
     }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId2);
         let effectiveServerKeys = serverKeys;
         if (connectAll) {
           effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
@@ -2634,7 +2634,7 @@ Rules
 
 Next Step
 Call query_semantic_metric_data with parameters derived from this definition.`;
-var createQueryMetricDefinitionTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
+var createQueryMetricDefinitionTool = ({ serverKeys, serverDescriptions, getTenantId: getTenantId2, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -2648,7 +2648,7 @@ ${serverKeys.map(
       datasourceId: inputDatasourceId
     }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId2);
         let effectiveServerKeys = serverKeys;
         if (connectAll) {
           effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
@@ -2867,7 +2867,7 @@ Semantic Model: ${semanticModel}`;
 `);
   return lines.join("\n");
 }
-var createQuerySemanticMetricDataTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
+var createQuerySemanticMetricDataTool = ({ serverKeys, serverDescriptions, getTenantId: getTenantId2, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -2884,7 +2884,7 @@ ${serverKeys.map(
       limit
     }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId2);
         let effectiveServerKeys = serverKeys;
         if (connectAll) {
           effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
@@ -2952,7 +2952,7 @@ ${serverKeys.map(
 import z12 from "zod";
 import { tool as tool11 } from "langchain";
 var QUERY_TABLES_LIST_DESCRIPTION = `Query available tables from a semantic metrics server. Returns a list of data tables with their schemas and descriptions. Use this tool to discover what tables are available in the data source.`;
-var createQueryTablesListTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
+var createQueryTablesListTool = ({ serverKeys, serverDescriptions, getTenantId: getTenantId2, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -2965,7 +2965,7 @@ ${serverKeys.map(
       datasourceIds
     }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId2);
         let effectiveServerKeys = serverKeys;
         if (connectAll) {
           effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
@@ -3056,7 +3056,7 @@ ${serverKeys.map(
 import z13 from "zod";
 import { tool as tool12 } from "langchain";
 var QUERY_TABLE_DEFINITION_DESCRIPTION = `Get detailed definition and schema for a specific table from a semantic metrics server. Returns comprehensive information including column definitions, SQL query, and table relationships.`;
-var createQueryTableDefinitionTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
+var createQueryTableDefinitionTool = ({ serverKeys, serverDescriptions, getTenantId: getTenantId2, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -3070,7 +3070,7 @@ ${serverKeys.map(
       datasourceId: inputDatasourceId
     }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId2);
         let effectiveServerKeys = serverKeys;
         if (connectAll) {
           effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
@@ -3194,7 +3194,7 @@ Example:
   },
   "limit": 100
 }`;
-var createExecuteSqlQueryTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
+var createExecuteSqlQueryTool = ({ serverKeys, serverDescriptions, getTenantId: getTenantId2, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -3210,7 +3210,7 @@ ${serverKeys.map(
       limit
     }, _exeConfig) => {
       try {
-        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId2);
         let effectiveServerKeys = serverKeys;
         if (connectAll) {
           effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
@@ -4528,6 +4528,7 @@ import {
   AgentType,
   hasTools,
   isDeepAgentConfig,
+  isProcessingAgentConfig,
   isTeamAgentConfig,
   getToolsFromConfig,
   getSubAgentsFromConfig
@@ -4837,6 +4838,285 @@ import { tool as tool38 } from "langchain";
 // src/tool_lattice/skill/load_skill_content.ts
 import z42 from "zod";
 import { tool as tool39 } from "langchain";
+
+// src/skill_lattice/builtinSkills.ts
+var BUILTIN_SKILLS = {
+  "create-skill": `---
+name: create-skill
+description: Create new skills, modify and improve existing skills. Use this skill whenever users mention creating a skill, wanting a new capability, asking to "make a skill for X", setting up automated workflows, or wanting to capture repeatable agent instructions \u2014 even if they don't use the word "skill."
+license: MIT
+metadata:
+  category: meta
+  version: "2.0"
+---
+
+# Skill Creator
+
+This skill guides you through creating and improving agent skills. Your job is to figure out where the user is in the process and help them progress \u2014 whether they're starting from scratch, have a rough idea, or want to improve an existing skill.
+
+At a high level, the process follows an iterative loop: **understand intent \u2192 interview \u2192 draft \u2192 test \u2192 review \u2192 improve \u2192 repeat** until satisfied. But always be flexible \u2014 if the user says "just vibe with me," do that instead.
+
+## Communicating With the User
+
+Users range from deep technical experts to people who just learned what a terminal is. Pay attention to context cues:
+- "JSON" and "assertion" \u2014 only use without explanation if the user shows comfort with them
+- "evaluation" and "benchmark" \u2014 borderline, briefly define if unsure
+- When in doubt, briefly explain terms. Short parenthetical definitions are fine.
+
+---
+
+## Step 1: Capture Intent
+
+Start by understanding what the user wants. The current conversation may already contain a workflow they want to capture (e.g., they say "turn this into a skill"). If so, extract answers from the conversation history first \u2014 the tools used, the sequence of steps, corrections made, input/output formats observed.
+
+Ask yourself:
+1. What capability does this skill enable?
+2. When should this skill trigger? (what user phrases, contexts, keywords)
+3. What is the expected output or behavior?
+4. Does it coordinate other skills (subSkills)?
+
+## Step 2: Interview and Research
+
+Proactively ask questions before writing anything:
+- **Edge cases**: What unusual inputs might arise? What should happen on failure?
+- **Input/output formats**: What formats are involved (files, data, text)?
+- **Dependencies**: Are specific tools, APIs, or data sources needed?
+- **Success criteria**: How will the user know the skill is working?
+
+Don't start writing until you've got clear answers. If the user is vague, ask clarifying questions \u2014 you'll save time by not guessing wrong.
+
+---
+
+## Step 3: Write the SKILL.md
+
+### Skill Directory Structure
+
+Skills use progressive disclosure \u2014 three levels of loading:
+
+\`\`\`
+skill-name/
+\u251C\u2500\u2500 SKILL.md              # Required \u2014 frontmatter + markdown body
+\u2514\u2500\u2500 resources/            # Optional \u2014 bundled files
+    \u251C\u2500\u2500 scripts/          # Executable code for repetitive tasks
+    \u251C\u2500\u2500 references/       # Docs loaded into context as needed
+    \u2514\u2500\u2500 assets/           # Files used in output (templates, icons)
+\`\`\`
+
+- **Metadata** (name + description) \u2014 always in context (~100 words)
+- **SKILL.md body** \u2014 loaded when skill triggers (aim for <500 lines)
+- **Bundled resources** \u2014 loaded as needed, unlimited
+
+If SKILL.md approaches 500 lines, add hierarchy with clear pointers to reference files.
+
+### File Location
+
+Write the skill to: \`/root/.agents/skills/{skill-name}/SKILL.md\`
+
+Resources go in: \`/root/.agents/skills/{skill-name}/resources/\`
+
+### Naming Rules
+
+Skill names (also the directory name) must follow these rules:
+- 1-64 characters, lowercase letters, digits, single hyphens
+- Pattern: \`^[a-z0-9]+(-[a-z0-9]+)*$\`
+- Cannot start or end with \`-\`, cannot contain consecutive \`--\`
+
+**Good**: \`pdf-processor\`, \`sql-query\`, \`code-review\`, \`data-analytics\`
+**Bad**: \`PDF-Processor\`, \`sql__query\`, \`-test\`, \`a\`
+
+### Frontmatter Reference
+
+\`\`\`yaml
+---
+name: my-skill-name         # Required \u2014 kebab-case identifier
+description: ...            # Required \u2014 what AND when (this drives triggering)
+license: MIT                # Optional
+compatibility: node         # Optional \u2014 runtime/context requirement
+metadata:                   # Optional \u2014 key-value tags for search/filter
+  category: tools
+  version: "1.0"
+subSkills:                  # Optional \u2014 coordinated sub-skill names
+  - sub-skill-1
+---
+
+# Markdown Body
+
+Instructional content for the agent.
+\`\`\`
+
+---
+
+## Writing Guide
+
+### The Description Field
+
+This is the most critical part. The description is the primary mechanism that determines whether an agent invokes your skill. Combine WHAT the skill does with specific contexts for WHEN to trigger.
+
+Agents tend to **undertrigger** \u2014 to not use skills when they'd be useful. To combat this, make descriptions a little "pushy":
+
+- Weak: "Helps with PDF files"
+- Better: "Extract text, tables, and metadata from PDF files. Use when users need to read, parse, or extract data from PDF documents."
+- Good: "Extract text, tables, and metadata from PDF files. Make sure to use this skill whenever the user mentions PDFs, extracting document data, or needs to read any kind of document file \u2014 even if they don't explicitly ask for 'PDF processing.'"
+
+Include domain-specific trigger words: file extensions, tool names, common user phrases.
+
+### Writing the Body
+
+Prefer **imperative form**. Write what the agent should DO, not what the skill IS:
+- "Check the database connection and verify table schemas" \u2014 good
+- "The database connection is checked and table schemas are verified" \u2014 weak
+
+**Explain WHY**, not just what. Use theory of mind \u2014 help the model understand the reasoning behind instructions so it can generalize to novel situations. If you find yourself writing ALWAYS or NEVER in all caps, that's a yellow flag \u2014 reframe and explain the reasoning.
+
+**Use examples** to ground abstract instructions:
+
+\`\`\`markdown
+## Commit message format
+**Example 1:**
+Input: Added user authentication with JWT tokens
+Output: feat(auth): implement JWT-based authentication
+\`\`\`
+
+**Define output formats** explicitly when structure matters:
+
+\`\`\`markdown
+## Report structure
+ALWAYS use this exact template:
+# [Title]
+## Executive summary
+## Key findings
+## Recommendations
+\`\`\`
+
+### Body Structure Checklist
+
+A well-written skill body typically includes:
+- **Role definition**: What role does the agent play when executing this skill?
+- **Workflow**: Step-by-step process in a clear sequence
+- **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.
+
+---
+
+## Step 4: Test and Iterate
+
+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?
+
+### Improving the Skill
+
+When iterating based on feedback:
+
+1. **Generalize from feedback** \u2014 don't overfit to the test cases. The skill will be used across many different prompts. If a fix only helps one specific example, think bigger.
+2. **Keep it lean** \u2014 remove instructions that aren't pulling their weight. Read the full transcripts, not just final outputs. If the skill makes the agent waste time, trim it.
+3. **Look for repeated work** \u2014 if all test runs involved writing the same helper script, bundle that script into \`resources/scripts/\` and have the skill reference it instead.
+4. **Explain the why** \u2014 if you're adding a constraint because of a failure, explain the context so the model understands when to apply it and when it's safe to deviate.
+
+Repeat the test \u2192 review \u2192 improve loop until the user is satisfied.
+
+---
+
+## Step 5: Optimize the Description (Optional)
+
+After the skill works well, offer to optimize the description for better triggering accuracy.
+
+### How Triggering Works
+
+The agent sees skills as a list of name + description pairs. It decides whether to consult a skill based on that description. Important: agents only consult skills for tasks they can't easily handle on their own. Simple one-step queries may not trigger a skill even if the description matches \u2014 so make sure the description emphasizes the COMPLEX or SPECIALIZED nature of the task.
+
+### Optimization Approach
+
+1. Create 10-15 eval queries \u2014 a mix of should-trigger and should-not-trigger prompts
+2. For **should-trigger** (6-8): different phrasings of the same intent \u2014 formal, casual, indirect. Include cases where the user doesn't explicitly name the skill but clearly needs it
+3. For **should-not-trigger** (6-8): focus on near-misses \u2014 queries that share keywords but need something different. Don't make them obviously irrelevant
+4. Test the description against these queries and adjust based on misfires
+5. Show the user before/after and explain what changed
+
+---
+
+## 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
+
+## Updating Existing Skills
+
+When the user wants to improve an existing skill:
+1. Read the current SKILL.md from \`/root/.agents/skills/{skill-name}/SKILL.md\`
+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
+
+---
+
+## Example Walkthrough
+
+**User**: "I want a skill that helps me analyze CSV data"
+
+**You** (interview):
+- "What kinds of analysis \u2014 summary stats, filtering, charting?"
+- "Are the CSVs always the same format or varied?"
+- "Should it output results as text, new CSV, or visualizations?"
+
+**User**: "Mostly summary stats and filtering. The files vary but all have headers."
+
+**You** (draft frontmatter):
+\`\`\`yaml
+---
+name: csv-analyzer
+description: Analyze CSV data with statistical summaries, filtering, and aggregation. Use whenever users want to explore, summarize, or extract insights from CSV files \u2014 even if they don't say "analyze" explicitly.
+metadata:
+  category: data
+  version: "1.0"
+---
+\`\`\`
+
+**You** (draft body): Write a workflow that teaches the agent to:
+1. Inspect the CSV structure and headers
+2. Let the user choose analysis type (summary, filter, aggregate)
+3. Execute the analysis and present results clearly
+4. Handle edge cases: missing headers, empty files, mixed types
+
+**You** (write): Create \`/root/.agents/skills/csv-analyzer/SKILL.md\`
+
+**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.
+`
+};
+function getBuiltInSkillMeta(name) {
+  const content = BUILTIN_SKILLS[name];
+  if (!content) return null;
+  try {
+    const { meta } = parseSkillFrontmatter(content);
+    return meta;
+  } catch {
+    return null;
+  }
+}
+function getBuiltInSkillContent(name) {
+  return BUILTIN_SKILLS[name];
+}
+function getAllBuiltInSkillMetas() {
+  return Object.keys(BUILTIN_SKILLS).map((name) => getBuiltInSkillMeta(name)).filter((meta) => meta !== null);
+}
+function getBuiltInSkillNames() {
+  return Object.keys(BUILTIN_SKILLS);
+}
+function isBuiltInSkill(name) {
+  return name in BUILTIN_SKILLS;
+}
+
+// src/tool_lattice/skill/load_skill_content.ts
 var LOAD_SKILL_CONTENT_DESCRIPTION = `
 Execute a skill within the main conversation
 
@@ -4877,6 +5157,11 @@ var createLoadSkillContentTool = () => {
   return tool39(
     async (input, _exe_config) => {
       try {
+        const builtInContent = getBuiltInSkillContent(input.skill_name);
+        if (builtInContent) {
+          const { meta: meta2, body: body2 } = parseSkillFrontmatter(builtInContent);
+          return buildSkillFile(meta2, body2);
+        }
         const sandbox = await getSandboxFromExeConfig(_exe_config);
         const filePath = `/root/.agents/skills/${input.skill_name}/SKILL.md`;
         let content;
@@ -4934,6 +5219,7 @@ function createSkillMiddleware(params = {}) {
       createLoadSkillContentTool()
     ],
     beforeAgent: async (state, runtime) => {
+      let resolvedSkills = [];
       try {
         const runConfig = runtime?.context?.runConfig || {};
         const manager = getSandBoxManager();
@@ -4963,13 +5249,24 @@ function createSkillMiddleware(params = {}) {
           }
         }
         if (readAll) {
-          latestSkills = allSkills;
+          resolvedSkills = allSkills;
         } else if (skills && skills.length > 0) {
-          latestSkills = allSkills.filter((skill) => skills.includes(skill.id));
+          resolvedSkills = allSkills.filter((skill) => skills.includes(skill.id));
+        } else {
+          resolvedSkills = allSkills;
         }
       } catch (error) {
         console.error("Error fetching skills:", error);
       }
+      const builtinMetas = getAllBuiltInSkillMetas();
+      for (const meta of builtinMetas) {
+        resolvedSkills.push({
+          id: meta.name,
+          name: meta.name,
+          description: meta.description
+        });
+      }
+      latestSkills = resolvedSkills;
     },
     wrapModelCall: (request, handler) => {
       const skillsPrompt = latestSkills.filter((skill) => !!skill.name).map((skill) => `## ${skill.name}
@@ -10533,6 +10830,125 @@ var InMemoryThreadMessageQueueStore = class {
   }
 };
 
+// src/store_lattice/InMemoryWorkflowTrackingStore.ts
+var InMemoryWorkflowTrackingStore = class {
+  constructor() {
+    this.runs = /* @__PURE__ */ new Map();
+    this.steps = /* @__PURE__ */ new Map();
+  }
+  async createWorkflowRun(request) {
+    const now = /* @__PURE__ */ new Date();
+    const run = {
+      id: `${request.threadId}_${Date.now()}`,
+      tenantId: request.tenantId,
+      assistantId: request.assistantId,
+      threadId: request.threadId,
+      status: "running",
+      topologyEdges: request.topologyEdges,
+      totalEdges: request.topologyEdges.length,
+      completedEdges: 0,
+      metadata: request.metadata || {},
+      startedAt: now,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.runs.set(run.id, run);
+    this.steps.set(run.id, []);
+    return run;
+  }
+  async getWorkflowRun(runId) {
+    return this.runs.get(runId) || null;
+  }
+  async updateWorkflowRun(runId, updates) {
+    const run = this.runs.get(runId);
+    if (!run) return null;
+    const updated = {
+      ...run,
+      ...updates,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.runs.set(runId, updated);
+    return updated;
+  }
+  async getWorkflowRunsByThreadId(tenantId, threadId) {
+    const results = [];
+    for (const run of this.runs.values()) {
+      if (run.tenantId === tenantId && run.threadId === threadId) {
+        results.push(run);
+      }
+    }
+    return results;
+  }
+  async getWorkflowRunsByAssistantId(tenantId, assistantId) {
+    const results = [];
+    for (const run of this.runs.values()) {
+      if (run.tenantId === tenantId && run.assistantId === assistantId) {
+        results.push(run);
+      }
+    }
+    return results;
+  }
+  async getWorkflowRunsByTenantId(tenantId) {
+    const results = [];
+    for (const run of this.runs.values()) {
+      if (run.tenantId === tenantId) {
+        results.push(run);
+      }
+    }
+    return results;
+  }
+  async createRunStep(request) {
+    const now = /* @__PURE__ */ new Date();
+    const step = {
+      id: `step_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      runId: request.runId,
+      tenantId: request.tenantId,
+      stepType: request.stepType,
+      stepName: request.stepName,
+      edgeFrom: request.edgeFrom,
+      edgeTo: request.edgeTo,
+      edgePurpose: request.edgePurpose,
+      input: request.input,
+      status: "running",
+      startedAt: now,
+      createdAt: now,
+      updatedAt: now
+    };
+    const runSteps = this.steps.get(request.runId) || [];
+    runSteps.push(step);
+    this.steps.set(request.runId, runSteps);
+    return step;
+  }
+  async updateRunStep(runId, stepId, updates) {
+    const runSteps = this.steps.get(runId);
+    if (!runSteps) return null;
+    const idx = runSteps.findIndex((s) => s.id === stepId);
+    if (idx === -1) return null;
+    const now = /* @__PURE__ */ new Date();
+    runSteps[idx] = {
+      ...runSteps[idx],
+      ...updates,
+      updatedAt: now
+    };
+    return runSteps[idx];
+  }
+  async getRunSteps(runId) {
+    return this.steps.get(runId) || [];
+  }
+  async getRunStepsByType(runId, stepType) {
+    const runSteps = this.steps.get(runId) || [];
+    return runSteps.filter((s) => s.stepType === stepType);
+  }
+  async getInterruptedSteps(runId) {
+    const runSteps = this.steps.get(runId) || [];
+    return runSteps.filter((s) => s.status === "interrupted");
+  }
+  clear() {
+    this.runs.clear();
+    this.steps.clear();
+  }
+};
+
 // src/store_lattice/StoreLatticeManager.ts
 var StoreLatticeManager = class _StoreLatticeManager extends BaseLatticeManager {
   /**
@@ -10689,6 +11105,12 @@ storeLatticeManager.registerLattice(
   "threadMessageQueue",
   defaultThreadMessageQueueStore
 );
+var defaultWorkflowTrackingStore = new InMemoryWorkflowTrackingStore();
+storeLatticeManager.registerLattice(
+  "default",
+  "workflowTracking",
+  defaultWorkflowTrackingStore
+);
 
 // src/services/Agent.ts
 import { Command as Command2 } from "@langchain/langgraph";
@@ -11031,6 +11453,7 @@ var Agent = class {
     this.abortController = null;
     this.queueMode = this.getDefaultQueueConfig();
     this.isWaitingForQueueEnd = false;
+    this.asyncTasks = [];
     this.agentExecutor = async ({ input, command, custom_run_config }, signal) => {
       const { runnable_agent, runConfig } = await this.getLatticeClientAndRuntimeConfig(custom_run_config);
       const { messages, ...rest } = input;
@@ -11809,6 +12232,23 @@ var Agent = class {
     console.log(namespacedEvent);
     event_bus_default.publish(namespacedEvent, data);
   }
+  addAsyncTask(task) {
+    this.asyncTasks.push(task);
+  }
+  getAsyncTasks() {
+    return this.asyncTasks;
+  }
+  getAsyncTask(taskId) {
+    return this.asyncTasks.find((t) => t.taskId === taskId);
+  }
+  updateAsyncTaskStatus(taskId, status) {
+    const task = this.getAsyncTask(taskId);
+    if (!task) return;
+    task.status = status;
+    if (status === "completed" || status === "failed" || status === "cancelled") {
+      task.completedAt = Date.now();
+    }
+  }
 };
 
 // src/services/AgentInstanceManager.ts
@@ -12434,9 +12874,9 @@ var ReActAgentGraphBuilder = class {
    */
   async build(agentLattice, params) {
     const tools = params.tools.map((t) => {
-      const tool50 = getToolClient(t.key);
-      return tool50;
-    }).filter((tool50) => tool50 !== void 0);
+      const tool51 = getToolClient(t.key);
+      return tool51;
+    }).filter((tool51) => tool51 !== void 0);
     const stateSchema2 = createReactAgentSchema(params.stateSchema);
     const middlewareConfigs = params.middleware || [];
     const filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
@@ -12860,6 +13300,25 @@ function getSubagents(options) {
   }
   return { agents, descriptions: subagentDescriptions };
 }
+function getAsyncPromptText() {
+  return `
+
+## Async Task Usage
+
+When tasks are independent and can run in parallel, use \`async: true\` to launch
+background tasks. The task returns immediately with a task ID.
+
+CRITICAL: After launching with \`async: true\`, move on immediately.
+- NEVER call check_async_task or list_async_tasks right after starting a task.
+- NEVER poll for task completion. The result will arrive as a notification.
+- Only check task status when the USER explicitly asks for an update.
+- If you receive an [Async task completed] notification, read it and incorporate
+  the result into your next response. Do not then call check_async_task repeatedly.
+- Task statuses in conversation history are stale \u2014 always use fresh tool calls
+  when the user asks.
+- Use cancel_async_task if the user wants to stop a running task.
+- Keep the full task_id: never truncate or abbreviate it.`;
+}
 function createTaskTool(options) {
   const {
     defaultModel,
@@ -12868,7 +13327,8 @@ function createTaskTool(options) {
     defaultInterruptOn,
     subagents,
     generalPurposeAgent,
-    taskDescription
+    taskDescription,
+    allowAsync
   } = options;
   const { agents: subagentGraphs, descriptions: subagentDescriptions } = getSubagents({
     defaultModel,
@@ -12881,7 +13341,7 @@ function createTaskTool(options) {
   const finalTaskDescription = taskDescription ? taskDescription : getTaskToolDescription(subagentDescriptions);
   return tool46(
     async (input, config) => {
-      const { description, subagent_type } = input;
+      const { description, subagent_type, async } = input;
       let assistant_id = subagent_type;
       if (subagent_type === "general-purpose") {
         assistant_id = config.configurable?.runConfig?.assistant_id + "-general-purpose";
@@ -12911,6 +13371,57 @@ function createTaskTool(options) {
         const subagentState = filterStateForSubagent(currentState);
         subagentState.messages = [new HumanMessage2({ content: description })];
         const subagent_thread_id = config.configurable?.thread_id + "____" + assistant_id + "_" + config.toolCall.id;
+        if (async) {
+          const tenantId = config.configurable?.runConfig?.tenantId;
+          const mainAssistantId = config.configurable?.runConfig?.assistant_id;
+          const mainThreadId = config.configurable?.runConfig?.thread_id;
+          const mainRuntimeAgent = agentInstanceManager.getAgent({
+            assistant_id: mainAssistantId,
+            thread_id: mainThreadId,
+            tenant_id: tenantId
+          });
+          if (mainRuntimeAgent) {
+            mainRuntimeAgent.addAsyncTask({
+              taskId: subagent_thread_id,
+              assistantId: assistant_id,
+              description: description.substring(0, 200),
+              status: "running",
+              createdAt: Date.now()
+            });
+          }
+          AgentManager.getInstance().callAgentInQueue({
+            assistant_id,
+            thread_id: subagent_thread_id,
+            input: { ...subagentState, message: description },
+            "x-tenant-id": tenantId,
+            runConfig: {
+              ...config.configurable?.runConfig,
+              assistant_id,
+              thread_id: subagent_thread_id
+            },
+            main_thread_id: mainThreadId,
+            main_tenant_id: tenantId,
+            main_assistant_id: mainAssistantId
+          }, false).catch((err) => {
+            console.error(`Failed to start async subagent ${subagent_thread_id}:`, err);
+          });
+          if (!config.toolCall?.id) {
+            throw new Error("Tool call ID is required for subagent invocation");
+          }
+          return new Command3({
+            update: {
+              messages: [
+                new ToolMessage4({
+                  content: `Async task started: ${subagent_thread_id}
+${description}
+The result will be delivered as a notification when complete. Do not poll.`,
+                  tool_call_id: config.toolCall.id,
+                  name: "task"
+                })
+              ]
+            }
+          });
+        }
         const workerResult = await agentWorkerGraph.invoke({
           assistant_id,
           thread_id: subagent_thread_id,
@@ -12952,7 +13463,186 @@ function createTaskTool(options) {
           `Name of the agent to use. Available: ${Object.keys(
             subagentGraphs
           ).join(", ")}`
-        )
+        ),
+        ...allowAsync ? {
+          async: z48.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."
+          )
+        } : {}
+      })
+    }
+  );
+}
+function getMainAgentFromConfig(config) {
+  const tenantId = config.configurable?.runConfig?.tenantId;
+  const mainAssistantId = config.configurable?.runConfig?.assistant_id;
+  const mainThreadId = config.configurable?.runConfig?.thread_id;
+  return agentInstanceManager.getAgent({
+    assistant_id: mainAssistantId,
+    thread_id: mainThreadId,
+    tenant_id: tenantId
+  });
+}
+function createCheckAsyncTaskTool() {
+  return tool46(
+    async (input, config) => {
+      const { task_id } = input;
+      const mainAgent = getMainAgentFromConfig(config);
+      if (!mainAgent) {
+        return "Cannot access main agent state.";
+      }
+      const cached = mainAgent.getAsyncTask(task_id);
+      if (!cached) {
+        return `Task ${task_id} not found. Use list_async_tasks to see all tasks.`;
+      }
+      try {
+        if (!agentInstanceManager.hasAgent({
+          assistant_id: cached.assistantId,
+          thread_id: task_id,
+          tenant_id: mainAgent.tenant_id
+        })) {
+          return `Task ${task_id}: not found (may have been cleaned up). Status was: ${cached.status}`;
+        }
+        const subAgent = agentInstanceManager.getAgent({
+          assistant_id: cached.assistantId,
+          thread_id: task_id,
+          tenant_id: mainAgent.tenant_id
+        });
+        const status = await subAgent.getRunStatus();
+        if (status === "busy") {
+          return `Task ${task_id}: still running.
+Description: ${cached.description}`;
+        }
+        if (status === "idle") {
+          const state = await subAgent.getCurrentState();
+          const messages = state.values.messages || [];
+          const lastAI = [...messages].reverse().find(
+            (m) => m.type === "ai" || m.getType?.() === "ai"
+          );
+          mainAgent.updateAsyncTaskStatus(task_id, "completed");
+          const result = lastAI?.content ?? "(completed, no output)";
+          return `Task ${task_id}: COMPLETED.
+Description: ${cached.description}
+Result:
+${result}`;
+        }
+        if (status === "error") {
+          mainAgent.updateAsyncTaskStatus(task_id, "failed");
+          return `Task ${task_id}: failed.
+Description: ${cached.description}`;
+        }
+        if (status === "interrupted") {
+          return `Task ${task_id}: interrupted (waiting for input).
+Description: ${cached.description}`;
+        }
+        return `Task ${task_id}: ${status}.
+Description: ${cached.description}`;
+      } catch (err) {
+        return `Task ${task_id}: error checking status: ${err instanceof Error ? err.message : String(err)}`;
+      }
+    },
+    {
+      name: "check_async_task",
+      description: "Get the current status and result of an async background task. Use this to check if a previously launched async task has completed.",
+      schema: z48.object({
+        task_id: z48.string().describe("The task ID returned when the async task was started")
+      })
+    }
+  );
+}
+function createListAsyncTasksTool() {
+  return tool46(
+    async (_input, config) => {
+      const mainAgent = getMainAgentFromConfig(config);
+      if (!mainAgent) {
+        return "Cannot access main agent state.";
+      }
+      const tasks = mainAgent.getAsyncTasks();
+      if (tasks.length === 0) {
+        return "No async tasks have been launched.";
+      }
+      for (const task of tasks) {
+        if (task.status === "completed" || task.status === "failed" || task.status === "cancelled") continue;
+        try {
+          if (!agentInstanceManager.hasAgent({
+            assistant_id: task.assistantId,
+            thread_id: task.taskId,
+            tenant_id: mainAgent.tenant_id
+          })) continue;
+          const subAgent = agentInstanceManager.getAgent({
+            assistant_id: task.assistantId,
+            thread_id: task.taskId,
+            tenant_id: mainAgent.tenant_id
+          });
+          const status = await subAgent.getRunStatus();
+          if (status === "idle") {
+            mainAgent.updateAsyncTaskStatus(task.taskId, "completed");
+          } else if (status === "error") {
+            mainAgent.updateAsyncTaskStatus(task.taskId, "failed");
+          }
+        } catch {
+        }
+      }
+      const lines = tasks.map((t) => {
+        const age = Math.floor((Date.now() - t.createdAt) / 1e3);
+        const ageStr = age < 60 ? `${age}s ago` : `${Math.floor(age / 60)}m ago`;
+        return `| ${t.taskId} | ${t.status} | ${ageStr} | ${t.description.substring(0, 80)} |`;
+      });
+      return [
+        "| task_id | status | age | description |",
+        "|---------|--------|-----|-------------|",
+        ...lines
+      ].join("\n");
+    },
+    {
+      name: "list_async_tasks",
+      description: "List all async background tasks with their current status. Use this before reporting task status to the user. Statuses in conversation history may be stale.",
+      schema: z48.object({})
+    }
+  );
+}
+function createCancelAsyncTaskTool() {
+  return tool46(
+    async (input, config) => {
+      const { task_id } = input;
+      const mainAgent = getMainAgentFromConfig(config);
+      if (!mainAgent) {
+        return "Cannot access main agent state.";
+      }
+      const cached = mainAgent.getAsyncTask(task_id);
+      if (!cached) {
+        return `Task ${task_id} not found.`;
+      }
+      try {
+        const subAgentExists = agentInstanceManager.hasAgent({
+          assistant_id: cached.assistantId,
+          thread_id: task_id,
+          tenant_id: mainAgent.tenant_id
+        });
+        if (subAgentExists) {
+          const subAgent = agentInstanceManager.getAgent({
+            assistant_id: cached.assistantId,
+            thread_id: task_id,
+            tenant_id: mainAgent.tenant_id
+          });
+          await subAgent.abort();
+          agentInstanceManager.removeAgent({
+            assistant_id: cached.assistantId,
+            thread_id: task_id,
+            tenant_id: mainAgent.tenant_id
+          });
+        }
+      } catch (err) {
+        return `Failed to cancel task ${task_id}: ${err instanceof Error ? err.message : String(err)}`;
+      }
+      mainAgent.updateAsyncTaskStatus(task_id, "cancelled");
+      return `Task ${task_id} cancelled.`;
+    },
+    {
+      name: "cancel_async_task",
+      description: "Cancel a running async background task.",
+      schema: z48.object({
+        task_id: z48.string().describe("The task ID to cancel")
       })
     }
   );
@@ -12966,7 +13656,8 @@ function createSubAgentMiddleware(options) {
     subagents = [],
     systemPrompt = TASK_SYSTEM_PROMPT,
     generalPurposeAgent = true,
-    taskDescription = null
+    taskDescription = null,
+    allowAsync = true
   } = options;
   const taskTool = createTaskTool({
     defaultModel,
@@ -12975,17 +13666,27 @@ function createSubAgentMiddleware(options) {
     defaultInterruptOn,
     subagents,
     generalPurposeAgent,
-    taskDescription
+    taskDescription,
+    allowAsync
   });
+  const allTools = [taskTool];
+  if (allowAsync) {
+    allTools.push(
+      createCheckAsyncTaskTool(),
+      createListAsyncTasksTool(),
+      createCancelAsyncTaskTool()
+    );
+  }
+  const effectiveSystemPrompt = allowAsync ? systemPrompt + getAsyncPromptText() : systemPrompt;
   return createMiddleware14({
     name: "subAgentMiddleware",
-    tools: [taskTool],
+    tools: allTools,
     wrapModelCall: async (request, handler) => {
-      if (systemPrompt !== null) {
+      if (effectiveSystemPrompt !== null) {
         const currentPrompt = request.systemPrompt || "";
         const newPrompt = currentPrompt ? `${currentPrompt}
 
-${systemPrompt}` : systemPrompt;
+${effectiveSystemPrompt}` : effectiveSystemPrompt;
         return handler({
           ...request,
           systemPrompt: newPrompt
@@ -14520,7 +15221,7 @@ var DeepAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool50) => tool50 !== void 0);
+    }).filter((tool51) => tool51 !== void 0);
     const subagents = await Promise.all(params.subAgents.map(async (sa) => {
       if (sa.client) {
         return {
@@ -16145,7 +16846,7 @@ var TeamAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool50) => tool50 !== void 0);
+    }).filter((tool51) => tool51 !== void 0);
     const teammates = params.subAgents.map((sa) => {
       const baseConfig = sa.config;
       return {
@@ -16182,17 +16883,444 @@ var TeamAgentGraphBuilder = class {
   }
 };
 
-// src/agent_lattice/builders/AgentGraphBuilderFactory.ts
-var AgentGraphBuilderFactory = class _AgentGraphBuilderFactory {
-  constructor() {
-    this.builders = /* @__PURE__ */ new Map();
-    this.registerDefaultBuilders();
+// src/deep_agent_new/processing_agent.ts
+import {
+  createAgent as createAgent6,
+  humanInTheLoopMiddleware as humanInTheLoopMiddleware3,
+  anthropicPromptCachingMiddleware as anthropicPromptCachingMiddleware2,
+  summarizationMiddleware as summarizationMiddleware2
+} from "langchain";
+
+// src/middlewares/topologyMiddleware.ts
+import { createMiddleware as createMiddleware18 } from "langchain";
+import { AIMessage as AIMessage3, ToolMessage as ToolMessage9 } from "@langchain/core/messages";
+import { tool as tool50 } from "langchain";
+import { z as z53 } from "zod";
+import { GraphInterrupt as GraphInterrupt4 } from "@langchain/langgraph";
+var CompletedEdgeSchema = z53.object({
+  to: z53.string(),
+  purpose: z53.string()
+});
+function deriveCompletedEdges(messages, edges) {
+  const completedToolCallIds = /* @__PURE__ */ new Set();
+  for (const msg of messages) {
+    if (msg.name === "task" && msg.tool_call_id && msg.status !== "error") {
+      completedToolCallIds.add(msg.tool_call_id);
+    }
+  }
+  const completed = [];
+  for (const msg of messages) {
+    if (!msg.tool_calls) continue;
+    for (const tc of msg.tool_calls) {
+      if (tc.name !== "task" || !completedToolCallIds.has(tc.id)) continue;
+      const targetAgent = tc.args?.subagent_type;
+      const edge = edges.find(
+        (e) => e.to === targetAgent
+      );
+      if (edge && !completed.some((e) => e.to === edge.to)) {
+        completed.push({ to: edge.to, purpose: edge.purpose });
+      }
+    }
   }
-  /**
-   * 获取单例实例
-   */
-  static getInstance() {
-    if (!_AgentGraphBuilderFactory.instance) {
+  return completed;
+}
+function createTopologyMiddleware(options) {
+  const { edges, trackingStore } = options;
+  return createMiddleware18({
+    name: "TopologyMiddleware",
+    contextSchema: z53.object({
+      runConfig: z53.any()
+    }),
+    stateSchema: z53.object({
+      currentAgentId: z53.string().default(""),
+      completedEdges: z53.array(CompletedEdgeSchema).default([]),
+      runId: z53.string().default(""),
+      stepIdMap: z53.record(z53.string()).default({})
+    }),
+    beforeAgent: async (state, runtime) => {
+      const runConfig = runtime.context?.runConfig ?? {};
+      const startingNode = edges[0]?.from ?? runConfig.assistant_id ?? "";
+      let runId = "";
+      if (trackingStore) {
+        try {
+          const run = await trackingStore.createWorkflowRun({
+            tenantId: runConfig.tenantId || "default",
+            assistantId: runConfig.assistant_id ?? "",
+            threadId: runConfig.thread_id ?? "",
+            topologyEdges: edges
+          });
+          runId = run.id;
+        } catch (err) {
+          console.error("[topologyMiddleware] Failed to create WorkflowRun:", err);
+        }
+      }
+      return {
+        currentAgentId: startingNode,
+        completedEdges: [],
+        runId,
+        stepIdMap: {}
+      };
+    },
+    wrapModelCall: async (request, handler) => {
+      const steps = edges.map((e, i) => `${i + 1}. \`${e.from}\` \u2192 \`${e.to}\` \u2014 ${e.purpose}`).join("\n");
+      const topologyPrompt = `## Workflow Execution Plan
+
+Your job is to execute this workflow by delegating each step to the specialized agent
+shown below. This is your core execution process \u2014 it is not optional.
+
+${steps || "(no workflow steps defined)"}
+
+Use the \`task\` tool to delegate work to each agent. Call \`read_topo_progress\` to
+see which steps are done and which are still pending.
+
+Do NOT delegate to any agent outside the current node's allowed paths \u2014 such attempts
+will be blocked.`;
+      const newSystemPrompt = request.systemPrompt ? `${topologyPrompt}
+
+---
+
+${request.systemPrompt}` : topologyPrompt;
+      return handler({ ...request, systemPrompt: newSystemPrompt });
+    },
+    tools: [
+      tool50(
+        async (_input) => {
+          return "placeholder";
+        },
+        {
+          name: "read_topo_progress",
+          description: "Check the current progress of the workflow execution plan. Returns which steps have been completed and which are still pending.",
+          schema: z53.object({})
+        }
+      )
+    ],
+    wrapToolCall: async (request, handler) => {
+      if (request.toolCall?.name === "read_topo_progress") {
+        const currentAgentId = request.state?.currentAgentId || "";
+        const completedEdges = request.state?.completedEdges || [];
+        const doneSet = new Set(completedEdges.map((e) => e.to));
+        const progress = edges.map((e) => ({
+          agent: e.to,
+          purpose: e.purpose,
+          status: doneSet.has(e.to) ? "done" : "pending"
+        }));
+        const doneCount = completedEdges.length;
+        return new ToolMessage9({
+          content: JSON.stringify(
+            {
+              currentAgentId,
+              progress: `${doneCount}/${edges.length} edges completed`,
+              steps: progress,
+              nextPending: progress.filter((s) => s.status === "pending").map((s) => s.agent)
+            },
+            null,
+            2
+          ),
+          name: "read_topo_progress",
+          tool_call_id: request.toolCall.id
+        });
+      }
+      try {
+        return await handler(request);
+      } catch (error) {
+        if (error instanceof GraphInterrupt4) {
+          throw error;
+        }
+        throw error;
+      }
+    },
+    afterModel: {
+      canJumpTo: ["model"],
+      hook: async (state, runtime) => {
+        const { messages, runId, stepIdMap: prevStepIdMap } = state;
+        let { currentAgentId } = state;
+        const runConfig = runtime.context?.runConfig ?? {};
+        const stepIdMap = { ...prevStepIdMap };
+        if (!messages || messages.length === 0) return;
+        const lastMessage = messages[messages.length - 1];
+        if ("tool_calls" in lastMessage) {
+          for (const tc of lastMessage.tool_calls) {
+            if (tc.name !== "task") continue;
+            const targetAgent = tc.args?.subagent_type;
+            const edge = edges.find(
+              (e) => e.from === currentAgentId && e.to === targetAgent
+            );
+            if (!edge) {
+              const myEdges = edges.filter(
+                (e) => e.from === currentAgentId
+              );
+              console.warn(
+                JSON.stringify({
+                  event: "topology_violation",
+                  currentAgentId,
+                  targetAgent,
+                  description: tc.args?.description,
+                  allowedTargets: myEdges.map((e) => e.to),
+                  threadId: runtime.configurable?.thread_id,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                })
+              );
+              const allowedList = myEdges.length > 0 ? [
+                `Agent \`${currentAgentId}\` may only delegate to:`,
+                ...myEdges.map(
+                  (e) => `- \`${e.to}\` \u2014 ${e.purpose}`
+                )
+              ] : [
+                `Agent \`${currentAgentId}\` has no outgoing delegation edges configured.`
+              ];
+              return {
+                messages: [
+                  new AIMessage3({
+                    content: [
+                      `Task rejected: topology violation.`,
+                      `Agent "${currentAgentId}" is not allowed to delegate to "${targetAgent}".`,
+                      ...allowedList,
+                      `Please delegate to one of the allowed agents above or handle the task yourself.`
+                    ].join("\n")
+                  })
+                ],
+                jumpTo: "model"
+              };
+            }
+            currentAgentId = edge.to;
+            if (trackingStore && runId) {
+              try {
+                const step = await trackingStore.createRunStep({
+                  runId,
+                  tenantId: runConfig.tenantId || "default",
+                  stepType: "task_delegation",
+                  stepName: targetAgent,
+                  edgeFrom: edge.from,
+                  edgeTo: edge.to,
+                  edgePurpose: edge.purpose,
+                  input: { description: tc.args?.description }
+                });
+                stepIdMap[edge.to] = step.id;
+              } catch (err) {
+                console.error("[topologyMiddleware] Failed to create RunStep:", err);
+              }
+            }
+          }
+        }
+        const completedEdges = deriveCompletedEdges(
+          messages,
+          edges
+        );
+        if (trackingStore && runId) {
+          for (const ce of completedEdges) {
+            const stepId = stepIdMap[ce.to];
+            if (!stepId) continue;
+            let output;
+            for (const msg of messages) {
+              if (msg.name === "task" && msg.tool_call_id) {
+                for (const tc of messages.find(
+                  (m) => m.tool_calls?.some((c) => c.id === msg.tool_call_id)
+                )?.tool_calls || []) {
+                  if (tc.id === msg.tool_call_id && tc.args?.subagent_type === ce.to) {
+                    output = msg.content;
+                    break;
+                  }
+                }
+                if (output) break;
+              }
+            }
+            if (output) {
+              try {
+                await trackingStore.updateRunStep(runId, stepId, {
+                  status: "completed",
+                  output: { result: output },
+                  completedAt: /* @__PURE__ */ new Date()
+                });
+              } catch (err) {
+                console.error("[topologyMiddleware] Failed to update RunStep output:", err);
+              }
+            }
+          }
+        }
+        if (trackingStore && runId) {
+          try {
+            await trackingStore.updateWorkflowRun(runId, {
+              completedEdges: completedEdges.length
+            });
+          } catch (err) {
+            console.error("[topologyMiddleware] Failed to update WorkflowRun completedEdges:", err);
+          }
+        }
+        return { currentAgentId, completedEdges, stepIdMap };
+      }
+    },
+    afterAgent: async (state, runtime) => {
+      const { runId, completedEdges } = state;
+      if (!trackingStore || !runId) return;
+      const allDone = completedEdges && completedEdges.length >= edges.length;
+      if (!allDone) return;
+      try {
+        await trackingStore.updateWorkflowRun(runId, {
+          status: "completed",
+          completedAt: /* @__PURE__ */ new Date()
+        });
+      } catch (err) {
+        console.error("[topologyMiddleware] Failed to finalize WorkflowRun:", err);
+      }
+    }
+  });
+}
+
+// src/deep_agent_new/processing_agent.ts
+var BASE_PROMPT2 = `In order to complete the objective that the user asks of you, you have access to a number of standard tools.`;
+function createProcessingAgent(params) {
+  const {
+    model = "claude-sonnet-4-5-20250929",
+    tools = [],
+    systemPrompt,
+    middleware: customMiddleware = [],
+    subagents = [],
+    responseFormat,
+    contextSchema: contextSchema2,
+    checkpointer,
+    store,
+    backend,
+    interruptOn,
+    name,
+    skills,
+    topologyEdges
+  } = params;
+  const finalSystemPrompt = systemPrompt ? `${systemPrompt}
+
+${BASE_PROMPT2}` : BASE_PROMPT2;
+  const filesystemBackend = backend ? backend : async (config) => new StateBackend(config);
+  let trackingStore;
+  try {
+    const storeLattice = getStoreLattice("default", "workflowTracking");
+    trackingStore = storeLattice.store;
+  } catch {
+  }
+  const middleware = [
+    // Workflow topology enforcement — replaces todoListMiddleware
+    createTopologyMiddleware({ edges: topologyEdges, trackingStore }),
+    // Enables filesystem operations and optional long-term memory storage
+    createFilesystemMiddleware({ backend: filesystemBackend }),
+    // Enables delegation to specialized subagents for complex tasks
+    createSubAgentMiddleware({
+      defaultModel: model,
+      defaultTools: tools,
+      defaultMiddleware: [
+        // Subagent middleware: Todo list management (subagents get todo, not topology)
+        todoListMiddleware(),
+        // Subagent middleware: Filesystem operations
+        createFilesystemMiddleware({
+          backend: filesystemBackend
+        }),
+        // Subagent middleware: Automatic conversation summarization
+        summarizationMiddleware2({
+          model,
+          trigger: { tokens: 17e4 },
+          keep: { messages: 6 }
+        }),
+        // Subagent middleware: Anthropic prompt caching
+        anthropicPromptCachingMiddleware2({
+          unsupportedModelBehavior: "ignore"
+        }),
+        // Subagent middleware: Patches tool calls
+        createPatchToolCallsMiddleware(),
+        ...customMiddleware
+      ],
+      defaultInterruptOn: interruptOn,
+      subagents,
+      generalPurposeAgent: true,
+      allowAsync: false
+    }),
+    // Automatically summarizes conversation history
+    summarizationMiddleware2({
+      model,
+      trigger: { tokens: 17e4 },
+      keep: { messages: 6 }
+    }),
+    // Enables Anthropic prompt caching
+    anthropicPromptCachingMiddleware2({
+      unsupportedModelBehavior: "ignore"
+    }),
+    // Patches tool calls
+    createPatchToolCallsMiddleware()
+  ];
+  if (interruptOn) {
+    middleware.push(humanInTheLoopMiddleware3({ interruptOn }));
+  }
+  middleware.push(...customMiddleware);
+  return createAgent6({
+    model,
+    systemPrompt: finalSystemPrompt,
+    tools,
+    middleware,
+    responseFormat,
+    contextSchema: contextSchema2,
+    checkpointer,
+    store,
+    name
+  });
+}
+
+// src/agent_lattice/builders/ProcessingAgentGraphBuilder.ts
+var ProcessingAgentGraphBuilder = class {
+  async build(agentLattice, params) {
+    const tools = params.tools.map((t) => {
+      const toolClient = getToolClient(t.key);
+      return toolClient;
+    }).filter((tool51) => tool51 !== void 0);
+    const subagents = await Promise.all(params.subAgents.map(async (sa) => {
+      if (sa.client) {
+        return {
+          key: sa.config.key,
+          name: sa.config.name,
+          description: sa.config.description,
+          runnable: sa.client
+        };
+      } else {
+        const subagentClient = await createAgentClientFromAgentLattice({
+          config: sa.config
+        });
+        return {
+          key: sa.config.key,
+          name: sa.config.name,
+          description: sa.config.description,
+          runnable: subagentClient
+        };
+      }
+    }));
+    const middlewareConfigs = params.middleware || [];
+    const filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
+    const middlewares = await createCommonMiddlewares(middlewareConfigs, filesystemBackend, true);
+    const topologyConfig = middlewareConfigs.find(
+      (m) => m.type === "topology" && m.enabled
+    );
+    const topologyEdges = topologyConfig?.config?.edges || [];
+    const processingAgent = createProcessingAgent({
+      tools,
+      model: params.model,
+      contextSchema: params.stateSchema,
+      systemPrompt: params.prompt,
+      subagents,
+      checkpointer: getCheckpointSaver("default"),
+      skills: params.skillCategories,
+      backend: filesystemBackend,
+      middleware: middlewares,
+      topologyEdges
+    });
+    return processingAgent;
+  }
+};
+
+// src/agent_lattice/builders/AgentGraphBuilderFactory.ts
+var AgentGraphBuilderFactory = class _AgentGraphBuilderFactory {
+  constructor() {
+    this.builders = /* @__PURE__ */ new Map();
+    this.registerDefaultBuilders();
+  }
+  /**
+   * 获取单例实例
+   */
+  static getInstance() {
+    if (!_AgentGraphBuilderFactory.instance) {
       _AgentGraphBuilderFactory.instance = new _AgentGraphBuilderFactory();
     }
     return _AgentGraphBuilderFactory.instance;
@@ -16204,6 +17332,7 @@ var AgentGraphBuilderFactory = class _AgentGraphBuilderFactory {
     this.builders.set(AgentType.REACT, new ReActAgentGraphBuilder());
     this.builders.set(AgentType.DEEP_AGENT, new DeepAgentGraphBuilder());
     this.builders.set(AgentType.TEAM, new TeamAgentGraphBuilder());
+    this.builders.set(AgentType.PROCESSING, new ProcessingAgentGraphBuilder());
   }
   /**
    * 注册自定义Builder
@@ -16233,7 +17362,8 @@ var AgentGraphBuilderFactory = class _AgentGraphBuilderFactory {
 import {
   getToolsFromConfig as getToolsFromConfig2,
   getSubAgentsFromConfig as getSubAgentsFromConfig2,
-  isDeepAgentConfig as isDeepAgentConfig2
+  isDeepAgentConfig as isDeepAgentConfig2,
+  isProcessingAgentConfig as isProcessingAgentConfig2
 } from "@axiom-lattice/protocols";
 var AgentParamsBuilder = class {
   /**
@@ -16252,7 +17382,7 @@ var AgentParamsBuilder = class {
    * @returns Agent build parameters
    */
   async buildParams(agentLattice, options) {
-    const skills = isDeepAgentConfig2(agentLattice.config) ? agentLattice.config.skillCategories : void 0;
+    const skills = isDeepAgentConfig2(agentLattice.config) || isProcessingAgentConfig2(agentLattice.config) ? agentLattice.config.skillCategories : void 0;
     const toolKeys = options?.overrideTools || getToolsFromConfig2(agentLattice.config);
     const tools = toolKeys.map((toolKey) => {
       const toolLattice = toolLatticeManager.getToolLattice(toolKey);
@@ -16283,7 +17413,7 @@ var AgentParamsBuilder = class {
       };
     }));
     let internalSubAgents = [];
-    if (isDeepAgentConfig2(agentLattice.config)) {
+    if (isDeepAgentConfig2(agentLattice.config) || isProcessingAgentConfig2(agentLattice.config)) {
       internalSubAgents = agentLattice.config.internalSubAgents?.map((i) => ({
         key: i.key,
         config: i
@@ -16468,6 +17598,39 @@ var SandboxSkillStore = class {
       projectId: options.projectId
     };
   }
+  /**
+   * Build a Skill object from a built-in skill definition.
+   */
+  _builtInSkill(name, tenantId) {
+    const content = getBuiltInSkillContent(name);
+    if (!content) return null;
+    const { meta } = parseSkillFrontmatter(content);
+    const now = /* @__PURE__ */ new Date();
+    return {
+      id: meta.name || name,
+      tenantId,
+      name: meta.name || name,
+      description: meta.description || "",
+      license: meta.license,
+      compatibility: meta.compatibility,
+      metadata: meta.metadata || {},
+      content,
+      subSkills: meta.subSkills,
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+  /**
+   * Get all built-in skills as Skill objects for a tenant.
+   */
+  _allBuiltInSkills(tenantId) {
+    const skills = [];
+    for (const name of Object.keys(BUILTIN_SKILLS)) {
+      const skill = this._builtInSkill(name, tenantId);
+      if (skill) skills.push(skill);
+    }
+    return skills;
+  }
   /**
    * Get sandbox manager
    */
@@ -16604,17 +17767,25 @@ ${body}` : `${frontmatter}
           }
         }
       }
+      const builtInSkills = this._allBuiltInSkills(tenantId);
+      for (const bis of builtInSkills) {
+        if (!skills.some((s) => s.id === bis.id)) {
+          skills.push(bis);
+        }
+      }
       console.log(`[SandboxSkillStore] Loaded ${skills.length} skills for tenant ${tenantId}`);
       return skills.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
     } catch (error) {
       console.error(`[SandboxSkillStore] Error listing skills for tenant ${tenantId}:`, error);
-      return [];
+      return this._allBuiltInSkills(tenantId);
     }
   }
   /**
     * Get skill by ID
     */
   async getSkillById(tenantId, id, context) {
+    const builtIn = this._builtInSkill(id, tenantId);
+    if (builtIn) return builtIn;
     return this.readSkillFile(tenantId, id, context);
   }
   /**
@@ -16622,6 +17793,11 @@ ${body}` : `${frontmatter}
     */
   async createSkill(tenantId, id, data, context) {
     validateSkillName(data.name);
+    if (isBuiltInSkill(data.name)) {
+      throw new Error(
+        `Skill "${data.name}" is a built-in skill and cannot be overwritten`
+      );
+    }
     if (id !== data.name) {
       throw new Error(
         `Skill id "${id}" must equal name "${data.name}" (name is used for path addressing)`
@@ -16652,6 +17828,11 @@ ${body}` : `${frontmatter}
     * Update an existing skill
     */
   async updateSkill(tenantId, id, updates, context) {
+    if (isBuiltInSkill(id)) {
+      throw new Error(
+        `Skill "${id}" is a built-in skill and cannot be modified`
+      );
+    }
     const skill = await this.readSkillFile(tenantId, id, context);
     if (!skill) {
       return null;
@@ -16694,6 +17875,11 @@ ${body}` : `${frontmatter}
     * Delete a skill by ID
     */
   async deleteSkill(tenantId, id, context) {
+    if (isBuiltInSkill(id)) {
+      throw new Error(
+        `Skill "${id}" is a built-in skill and cannot be deleted`
+      );
+    }
     try {
       const sandbox = await this.getSandbox(tenantId, context);
       const dirPath = this.getSkillDirectoryPath(tenantId, id);
@@ -16713,6 +17899,7 @@ ${body}` : `${frontmatter}
     * Check if skill exists
     */
   async hasSkill(tenantId, id, context) {
+    if (isBuiltInSkill(id)) return true;
     const skill = await this.getSkillById(tenantId, id, context);
     return skill !== null;
   }
@@ -16758,6 +17945,1013 @@ ${body}` : `${frontmatter}
   }
 };
 
+// src/agent_lattice/agentArchitectTools.ts
+import z54 from "zod";
+import { v4 as v42 } from "uuid";
+import { AgentType as AgentType2 } from "@axiom-lattice/protocols";
+function getTenantId(exeConfig) {
+  const runConfig = exeConfig?.configurable?.runConfig || {};
+  return runConfig.tenantId || "default";
+}
+function getAssistStore() {
+  return getStoreLattice("default", "assistant").store;
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-") || "agent";
+}
+async function generateAgentId(tenantId, name) {
+  const store = getAssistStore();
+  const base = slugify(name);
+  let id = base;
+  let counter = 2;
+  while (true) {
+    const existing = await store.getAssistantById(tenantId, id);
+    if (!existing) return id;
+    id = `${base}-${counter}`;
+    counter++;
+  }
+}
+registerToolLattice(
+  "list_agents",
+  {
+    name: "list_agents",
+    description: "List all agents for the current workspace. Returns a summary with id, name, description, and type for each agent.",
+    schema: z54.object({})
+  },
+  async (_input, exeConfig) => {
+    try {
+      const tenantId = getTenantId(exeConfig);
+      const store = getAssistStore();
+      const agents = await store.getAllAssistants(tenantId);
+      return JSON.stringify({
+        agents: agents.map((a) => ({
+          id: a.id,
+          name: a.name,
+          description: a.description || "",
+          type: a.graphDefinition?.type || "react",
+          createdAt: a.createdAt,
+          updatedAt: a.updatedAt
+        }))
+      });
+    } catch (error) {
+      return JSON.stringify({ error: `Failed to list agents: ${error.message}` });
+    }
+  }
+);
+registerToolLattice(
+  "get_agent",
+  {
+    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: z54.object({
+      id: z54.string().describe("The agent ID to retrieve")
+    })
+  },
+  async (input, exeConfig) => {
+    try {
+      const tenantId = getTenantId(exeConfig);
+      const store = getAssistStore();
+      const agent = await store.getAssistantById(tenantId, input.id);
+      if (!agent) {
+        return JSON.stringify({ error: `Agent '${input.id}' not found` });
+      }
+      return JSON.stringify(agent.graphDefinition);
+    } catch (error) {
+      return JSON.stringify({ error: `Failed to get agent: ${error.message}` });
+    }
+  }
+);
+var middlewareConfigSchema = z54.object({
+  id: z54.string(),
+  type: z54.string(),
+  name: z54.string(),
+  description: z54.string(),
+  enabled: z54.boolean(),
+  config: z54.record(z54.any()).optional()
+});
+var createAgentSchema = z54.object({
+  name: z54.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: z54.string().optional().describe("Short description"),
+  type: z54.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: z54.string().describe("System prompt for the agent"),
+  tools: z54.array(z54.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: z54.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: z54.array(z54.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
+  internalSubAgents: z54.array(z54.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
+  modelKey: z54.string().optional().describe("Model key to use")
+});
+registerToolLattice(
+  "create_agent",
+  {
+    name: "create_agent",
+    description: "Create and save a new REACT or DEEP_AGENT. For PROCESSING agents, use create_processing_agent instead. Returns the new agent's ID and name. NOTE: 'tools' is a string array of tool names, 'middleware' is an object array of middleware configs \u2014 they are separate fields and must not be mixed. IMPORTANT: If the agent needs user confirmation, approval, or must ask clarifying questions, include the 'ask_user_to_clarify' middleware (type: 'ask_user_to_clarify', no config required).",
+    schema: createAgentSchema
+  },
+  async (input, exeConfig) => {
+    try {
+      const tenantId = getTenantId(exeConfig);
+      const store = getAssistStore();
+      const id = await generateAgentId(tenantId, input.name);
+      const config = {
+        key: id,
+        name: input.name,
+        description: input.description || "",
+        type: input.type === "deep_agent" ? AgentType2.DEEP_AGENT : AgentType2.REACT,
+        prompt: input.prompt,
+        ...input.tools && input.tools.length > 0 ? { tools: input.tools } : {},
+        ...input.middleware && input.middleware.length > 0 ? { middleware: input.middleware } : {},
+        ...input.subAgents && input.subAgents.length > 0 ? { subAgents: input.subAgents } : {},
+        ...input.internalSubAgents ? { internalSubAgents: input.internalSubAgents } : {},
+        ...input.modelKey ? { modelKey: input.modelKey } : {}
+      };
+      await store.createAssistant(tenantId, id, {
+        name: input.name,
+        description: input.description,
+        graphDefinition: config
+      });
+      return JSON.stringify({ id, name: input.name, type: input.type });
+    } catch (error) {
+      return JSON.stringify({ error: `Failed to create agent: ${error.message}` });
+    }
+  }
+);
+var topologyEdgeSchema = z54.object({
+  from: z54.string().describe("Source agent ID. For the first edge, this is the orchestrator (use the orchestrator's name as a placeholder \u2014 the tool will replace it with the actual ID). For subsequent chained edges, this is the previous stage's sub-agent ID."),
+  to: z54.string().describe("Target agent ID (the sub-agent to delegate to)"),
+  purpose: z54.string().describe("Business purpose of this delegation step \u2014 what the sub-agent should accomplish")
+});
+var createProcessingAgentSchema = z54.object({
+  name: z54.string().describe("Display name for the processing agent"),
+  description: z54.string().optional().describe("Short description"),
+  prompt: z54.string().describe("System prompt for the orchestrator. Should describe how to route tasks through the topology."),
+  edges: z54.array(topologyEdgeSchema).min(1).describe("Topology edges defining the workflow. Each edge describes a delegation step with its business purpose. The orchestrator will follow this topology to delegate tasks to sub-agents."),
+  tools: z54.array(z54.string()).optional().describe("Tool keys (strings) to assign to the orchestrator. 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. Do NOT put middleware-like objects here \u2014 middleware goes in the separate 'middleware' field."),
+  subAgents: z54.array(z54.string()).describe("IDs of sub-agents that form the workflow pipeline. These must be created first via create_agent."),
+  internalSubAgents: z54.array(z54.any()).optional().describe("Inline sub-agent configs (alternative to pre-created sub-agents)"),
+  middleware: z54.array(middlewareConfigSchema).optional().describe("Additional middleware config objects beyond the auto-managed topology middleware. Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
+  modelKey: z54.string().optional().describe("Model key to use")
+}).refine(
+  (data) => {
+    const edgeTargets = new Set(data.edges.map((e) => e.to));
+    const subAgentIds = new Set(data.subAgents);
+    for (const target of edgeTargets) {
+      if (!subAgentIds.has(target)) {
+        return false;
+      }
+    }
+    return true;
+  },
+  { message: "All edge targets (to) must be included in the subAgents list" }
+);
+registerToolLattice(
+  "create_processing_agent",
+  {
+    name: "create_processing_agent",
+    description: "Create a PROCESSING agent with a business-defined workflow topology. The edges define a serial delegation chain: the first edge starts from the orchestrator (use its name as placeholder), then each subsequent edge chains from the previous stage's sub-agent. Sub-agents must be created first via create_agent. NOTE: 'tools' is a string array of tool names, 'middleware' is an object array \u2014 they are separate fields and must not be mixed. IMPORTANT: If any sub-agent or the orchestrator needs user confirmation/approval, include the 'ask_user_to_clarify' middleware on that specific agent.",
+    schema: createProcessingAgentSchema
+  },
+  async (input, exeConfig) => {
+    try {
+      const tenantId = getTenantId(exeConfig);
+      const store = getAssistStore();
+      const id = await generateAgentId(tenantId, input.name);
+      const normalize = (s) => s.toLowerCase().replace(/[_\-\s]/g, "");
+      const resolveFrom = (rawFrom) => {
+        const fromLower = rawFrom.toLowerCase();
+        const nameLower = input.name.toLowerCase();
+        if (fromLower === nameLower || fromLower === "orchestrator" || fromLower === "orchestrator-id" || normalize(rawFrom) === normalize(input.name)) {
+          return id;
+        }
+        return rawFrom;
+      };
+      const topologyMiddleware = {
+        id: "topology",
+        type: "topology",
+        name: "Topology",
+        description: `Enforce ${input.edges.length}-step workflow topology`,
+        enabled: true,
+        config: {
+          edges: input.edges.map((e) => ({
+            from: resolveFrom(e.from),
+            to: e.to,
+            purpose: e.purpose
+          }))
+        }
+      };
+      const additionalMiddleware = input.middleware || [];
+      const middleware = [topologyMiddleware, ...additionalMiddleware];
+      const config = {
+        key: id,
+        name: input.name,
+        description: input.description || "",
+        type: AgentType2.PROCESSING,
+        prompt: input.prompt,
+        ...input.tools && input.tools.length > 0 ? { tools: input.tools } : {},
+        middleware,
+        subAgents: input.subAgents,
+        ...input.internalSubAgents ? { internalSubAgents: input.internalSubAgents } : {},
+        ...input.modelKey ? { modelKey: input.modelKey } : {}
+      };
+      await store.createAssistant(tenantId, id, {
+        name: input.name,
+        description: input.description,
+        graphDefinition: config
+      });
+      return JSON.stringify({
+        id,
+        name: input.name,
+        type: "processing",
+        topology: {
+          edges: input.edges.map((e) => ({ from: resolveFrom(e.from), to: e.to, purpose: e.purpose }))
+        }
+      });
+    } catch (error) {
+      return JSON.stringify({ error: `Failed to create processing agent: ${error.message}` });
+    }
+  }
+);
+var updateProcessingAgentSchema = z54.object({
+  id: z54.string().describe("The PROCESSING agent ID to update"),
+  name: z54.string().optional().describe("New display name for the orchestrator"),
+  description: z54.string().optional().describe("New short description"),
+  prompt: z54.string().optional().describe("New system prompt for the orchestrator"),
+  edges: z54.array(topologyEdgeSchema).min(1).optional().describe("New topology edges. First edge's from must reference the orchestrator by name (the tool replaces it). Subsequent edges chain from previous sub-agent IDs."),
+  tools: z54.array(z54.string()).optional().describe("Tool keys (strings) to assign to the orchestrator. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array \u2014 do NOT put middleware-like objects here."),
+  subAgents: z54.array(z54.string()).optional().describe("New IDs of sub-agents in the workflow pipeline"),
+  middleware: z54.array(middlewareConfigSchema).optional().describe("Additional middleware config objects (topology middleware is auto-managed, do not include it). Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
+  modelKey: z54.string().optional().describe("New model key")
+}).refine(
+  (data) => {
+    if (!data.edges) return true;
+    const subAgentIds = new Set(data.subAgents || []);
+    if (subAgentIds.size === 0) return true;
+    const edgeTargets = new Set(data.edges.map((e) => e.to));
+    for (const target of edgeTargets) {
+      if (!subAgentIds.has(target)) {
+        return false;
+      }
+    }
+    return true;
+  },
+  { message: "All edge targets (to) must be included in the subAgents list" }
+);
+registerToolLattice(
+  "update_processing_agent",
+  {
+    name: "update_processing_agent",
+    description: "Update an existing PROCESSING agent's topology edges, name, prompt, tools, or sub-agents. Use this instead of update_agent for PROCESSING agents because edges require proper placeholder resolution and topology middleware management. NOTE: 'tools' is a string array of tool names, 'middleware' is an object array \u2014 they are separate fields and must not be mixed. For user approval/confirmation scenarios, add middleware with type: 'ask_user_to_clarify'.",
+    schema: updateProcessingAgentSchema
+  },
+  async (input, exeConfig) => {
+    try {
+      const tenantId = getTenantId(exeConfig);
+      const store = getAssistStore();
+      const existing = await store.getAssistantById(tenantId, input.id);
+      if (!existing) {
+        return JSON.stringify({ error: `Agent '${input.id}' not found` });
+      }
+      const existingConfig = existing.graphDefinition || {};
+      if (existingConfig.type !== AgentType2.PROCESSING) {
+        return JSON.stringify({ error: `Agent '${input.id}' is not a PROCESSING agent (type: ${existingConfig.type})` });
+      }
+      const normalize = (s) => s.toLowerCase().replace(/[_\-\s]/g, "");
+      const orchestratorName = input.name || existingConfig.name || existing.name || "";
+      const resolveFrom = (rawFrom) => {
+        const fromLower = rawFrom.toLowerCase();
+        const nameLower = orchestratorName.toLowerCase();
+        if (fromLower === nameLower || fromLower === "orchestrator" || fromLower === "orchestrator-id" || normalize(rawFrom) === normalize(orchestratorName)) {
+          return input.id;
+        }
+        return rawFrom;
+      };
+      let middleware = existingConfig.middleware || [];
+      let resolvedEdges;
+      if (input.edges) {
+        resolvedEdges = input.edges.map((e) => ({
+          from: resolveFrom(e.from),
+          to: e.to,
+          purpose: e.purpose
+        }));
+        const topoIndex = middleware.findIndex(
+          (m) => m.type === "topology"
+        );
+        const topoMiddleware = {
+          id: "topology",
+          type: "topology",
+          name: "Topology",
+          description: `Enforce ${resolvedEdges.length}-step workflow topology`,
+          enabled: true,
+          config: { edges: resolvedEdges }
+        };
+        if (topoIndex >= 0) {
+          middleware = [...middleware];
+          middleware[topoIndex] = topoMiddleware;
+        } else {
+          middleware = [topoMiddleware, ...middleware];
+        }
+        if (input.middleware) {
+          const nonTopo = input.middleware.filter(
+            (m) => m.type !== "topology"
+          );
+          const topoIdx = middleware.findIndex(
+            (m) => m.type === "topology"
+          );
+          const prefix = middleware.slice(0, topoIdx + 1);
+          const suffix = middleware.slice(topoIdx + 1);
+          middleware = [...prefix, ...nonTopo];
+        }
+      } else if (input.middleware) {
+        const nonTopo = input.middleware.filter(
+          (m) => m.type !== "topology"
+        );
+        const topoIdx = middleware.findIndex(
+          (m) => m.type === "topology"
+        );
+        if (topoIdx >= 0) {
+          middleware = [...middleware.slice(0, topoIdx + 1), ...nonTopo];
+        } else {
+          middleware = [...middleware, ...nonTopo];
+        }
+      }
+      const mergedConfig = {
+        ...existingConfig,
+        ...input.name !== void 0 ? { name: input.name } : {},
+        ...input.description !== void 0 ? { description: input.description } : {},
+        ...input.prompt !== void 0 ? { prompt: input.prompt } : {},
+        ...input.tools !== void 0 ? { tools: input.tools } : {},
+        ...input.subAgents !== void 0 ? { subAgents: input.subAgents } : {},
+        ...input.modelKey !== void 0 ? { modelKey: input.modelKey } : {},
+        middleware,
+        key: input.id
+      };
+      const newName = input.name || existing.name;
+      await store.updateAssistant(tenantId, input.id, {
+        name: newName,
+        description: input.description !== void 0 ? input.description : existing.description,
+        graphDefinition: mergedConfig
+      });
+      const topoConfig = middleware.find(
+        (m) => m.type === "topology"
+      );
+      return JSON.stringify({
+        id: input.id,
+        name: newName,
+        type: "processing",
+        topology: {
+          edges: topoConfig?.config?.edges || resolvedEdges || []
+        }
+      });
+    } catch (error) {
+      return JSON.stringify({ error: `Failed to update processing agent: ${error.message}` });
+    }
+  }
+);
+var updateAgentSchema = z54.object({
+  id: z54.string().describe("The agent ID to update"),
+  config: z54.object({
+    name: z54.string().optional().describe("New display name for the agent"),
+    description: z54.string().optional().describe("New short description"),
+    type: z54.enum(["react", "deep_agent"]).optional().describe("Agent type"),
+    prompt: z54.string().optional().describe("New system prompt for the agent"),
+    tools: z54.array(z54.string()).optional().describe("Tool keys to assign to this agent. These are registered tool names (strings), NOT middleware objects."),
+    middleware: z54.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: z54.array(z54.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
+    internalSubAgents: z54.array(z54.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
+    modelKey: z54.string().optional().describe("Model key to use")
+  }).describe("Configuration fields to update. Only include the fields you want to change.")
+});
+registerToolLattice(
+  "update_agent",
+  {
+    name: "update_agent",
+    description: "Update an existing agent's configuration. Provide the agent ID and the fields to change. Returns the updated agent's ID and name. NOTE: For user approval/confirmation scenarios, add middleware with type: 'ask_user_to_clarify'.",
+    schema: updateAgentSchema
+  },
+  async (input, exeConfig) => {
+    try {
+      const tenantId = getTenantId(exeConfig);
+      const store = getAssistStore();
+      const existing = await store.getAssistantById(tenantId, input.id);
+      if (!existing) {
+        return JSON.stringify({ error: `Agent '${input.id}' not found` });
+      }
+      const existingConfig = existing.graphDefinition || {};
+      const mergedConfig = { ...existingConfig, ...input.config };
+      const newName = input.config.name || existing.name;
+      await store.updateAssistant(tenantId, input.id, {
+        name: newName,
+        description: input.config.description !== void 0 ? input.config.description : existing.description,
+        graphDefinition: mergedConfig
+      });
+      return JSON.stringify({ id: input.id, name: newName });
+    } catch (error) {
+      return JSON.stringify({ error: `Failed to update agent: ${error.message}` });
+    }
+  }
+);
+registerToolLattice(
+  "delete_agent",
+  {
+    name: "delete_agent",
+    description: "Permanently delete an agent by its ID. This action cannot be undone.",
+    schema: z54.object({
+      id: z54.string().describe("The agent ID to delete")
+    })
+  },
+  async (input, exeConfig) => {
+    try {
+      const tenantId = getTenantId(exeConfig);
+      const store = getAssistStore();
+      const existing = await store.getAssistantById(tenantId, input.id);
+      if (!existing) {
+        return JSON.stringify({ error: `Agent '${input.id}' not found`, success: false });
+      }
+      const success = await store.deleteAssistant(tenantId, input.id);
+      return JSON.stringify({ success, id: input.id });
+    } catch (error) {
+      return JSON.stringify({ error: `Failed to delete agent: ${error.message}` });
+    }
+  }
+);
+registerToolLattice(
+  "list_tools",
+  {
+    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: z54.object({})
+  },
+  async (_input, _exeConfig) => {
+    try {
+      const lattices = toolLatticeManager.getAllLattices();
+      return JSON.stringify({
+        tools: lattices.map((l) => ({
+          name: l.config.name,
+          description: l.config.description,
+          needUserApprove: l.config.needUserApprove ?? false
+        }))
+      });
+    } catch (error) {
+      return JSON.stringify({ error: `Failed to list tools: ${error.message}` });
+    }
+  }
+);
+registerToolLattice(
+  "invoke_agent",
+  {
+    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: z54.object({
+      id: z54.string().describe("The agent ID to invoke"),
+      message: z54.string().describe("The test message to send to the agent")
+    })
+  },
+  async (input, exeConfig) => {
+    try {
+      const tenantId = getTenantId(exeConfig);
+      const { id, message } = input;
+      const store = getAssistStore();
+      const existing = await store.getAssistantById(tenantId, id);
+      if (!existing) {
+        return JSON.stringify({ error: `Agent '${id}' not found` });
+      }
+      const threadId = v42();
+      const agent = new Agent({
+        tenant_id: tenantId,
+        assistant_id: id,
+        thread_id: threadId
+      });
+      const result = await agent.invoke({ input: { message } });
+      const messages = result?.messages || [];
+      const lastAi = [...messages].reverse().find(
+        (m) => m.role === "ai" || m.type === "ai"
+      );
+      const content = lastAi?.content ?? "(no response)";
+      return JSON.stringify({
+        agentId: id,
+        threadId,
+        response: typeof content === "string" ? content : JSON.stringify(content)
+      });
+    } catch (error) {
+      return JSON.stringify({ error: `Failed to invoke agent: ${error.message}` });
+    }
+  }
+);
+
+// src/agent_lattice/agentArchitectConfig.ts
+import { AgentType as AgentType3 } from "@axiom-lattice/protocols";
+
+// src/agent_lattice/agentArchitectPrompt.ts
+var AGENT_ARCHITECT_PROMPT = `# Agent Architect
+
+You are an **Agent Architect** \u2014 an expert AI system designer. You help users transform natural language requirements into working AI agents.
+
+## Your Tools
+
+You have nine tools:
+- **list_agents** \u2014 See all existing agents for this workspace
+- **list_tools** \u2014 See all available tools that can be assigned to agents
+- **get_agent** \u2014 View the full configuration of a specific agent
+- **create_agent** \u2014 Create a REACT or DEEP_AGENT agent
+- **create_processing_agent** \u2014 Create a PROCESSING agent with business-defined workflow topology
+- **update_processing_agent** \u2014 Modify a PROCESSING agent's topology edges, name, prompt, or sub-agents
+- **update_agent** \u2014 Modify an existing REACT or DEEP_AGENT agent's configuration
+- **delete_agent** \u2014 Remove an agent permanently
+- **invoke_agent** \u2014 Test an agent by sending a message and getting its response
+
+## Global Interaction Rules
+
+1. **One question at a time.** Never overwhelm the user. Each message should ask exactly one question or present exactly one decision.
+2. **Confirm before creating.** Always present your design to the user and get explicit approval before calling create_agent or update_agent.
+3. **Be concise.** Show configs clearly but briefly. Use structured formats when presenting designs.
+4. **Use kebab-case for agent names.** E.g., "code-reviewer", "data-analyzer".
+
+---
+
+## Agent Types Overview
+
+| Type | Best for | Execution Model |
+|------|----------|----------------|
+| **react** | Simple, single-responsibility tasks | Classic ReAct loop (think \u2192 act \u2192 observe) |
+| **processing** | Standard BPO workflows, preset process orchestration | Topology-driven: predefined agent topology with reliable multi-agent coordination |
+| **deep_agent** | Complex, open-ended tasks requiring dynamic decomposition | Self-generating dynamic todos: agent analyzes the task and creates its own execution plan at runtime |
+
+---
+
+## Workflow A: Simple Agent (REACT type)
+
+Use this for straightforward tasks \u2014 a single agent with a single responsibility, no sub-agent decomposition needed. The classic ReAct pattern: the agent reasons, acts, and observes in a loop.
+
+### Step 1: Understand the Goal
+Ask: What should this agent do? Who will use it? What are the inputs and outputs?
+
+### Step 2: Choose Middleware
+Based on the goal, recommend which middleware the agent needs. Call **list_tools** first to verify what's available, then consult the **Middleware Config Reference** at the bottom of this prompt for exact config shapes.
+
+**IMPORTANT:** If the agent needs user confirmation, approval, or must ask the user clarifying questions, you MUST include the **ask_user_to_clarify** middleware. Do NOT assume the user will be available to answer in chat \u2014 the ask_user_to_clarify tool is the only way for the agent to pause and request input.
+
+### Step 3: Write the System Prompt
+Craft the agent's system prompt with:
+1. **Role definition** \u2014 Who the agent is and what it does
+2. **Workflow** \u2014 Step-by-step instructions
+3. **Constraints** \u2014 Boundaries, quality standards, forbidden actions
+
+Present the prompt. Get user confirmation.
+
+### Step 4: Create
+Call create_agent with the agreed configuration.
+
+---
+
+## Workflow B: Workflow Agent (PROCESSING type)
+
+Use this when the task follows a standard BPO (Business Process Orchestration) pattern \u2014 a predefined topology of sub-agents working through a preset pipeline or process. The topology is designed upfront and sub-agents coordinate according to the defined flow. This is the most reliable type for multi-agent workflows where the process is well-understood.
+
+### Phase 1: Process Analysis
+
+Ask: What is the end-to-end process we need to automate? What are the stages?
+
+Based on the answer, identify the processing stages. Output a **pipeline**:
+
+\`\`\`
+I see the following processing stages:
+\u251C\u2500\u2500 Input Intake: [what happens]
+\u251C\u2500\u2500 Stage 1: [processing step]
+\u251C\u2500\u2500 Stage 2: [processing step]
+\u2514\u2500\u2500 Output: [final deliverable]
+
+Do these stages look right?
+\`\`\`
+
+### Phase 2: Topology Design
+
+Define the agent topology. Each stage may be handled by a dedicated sub-agent. Create a **topology diagram**:
+
+\`\`\`
+    \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510      \u250C\u2500\u2500\u2500\u2500\u2510      \u250C\u2500\u2500\u2500\u2500\u2510      \u250C\u2500\u2500\u2500\u2500\u2510
+    \u2502  Orchestrator    \u2502 \u2500\u2500\u25BA  \u2502Stage\u2502 \u2500\u2500\u25BA  \u2502Stage\u2502 \u2500\u2500\u25BA  \u2502Stage\u2502
+    \u2502                  \u2502      \u2502  1  \u2502      \u2502  2  \u2502      \u2502  3  \u2502
+    \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518      \u2514\u2500\u2500\u2500\u2500\u2518      \u2514\u2500\u2500\u2500\u2500\u2518      \u2514\u2500\u2500\u2500\u2500\u2518
+
+Flow: Orchestrator \u2192 Stage 1 \u2192 Stage 2 \u2192 Stage 3 \u2192 Output
+
+Each edge chains from the previous node:
+  Orchestrator \u2500\u2500\u25BA Stage 1 \u2500\u2500\u25BA Stage 2 \u2500\u2500\u25BA Stage 3
+\`\`\`
+
+**Design checks:**
+- Each stage has exactly one responsibility
+- The flow between stages is a serial chain \u2014 each stage processes output from the previous one
+- The orchestrator directs the first stage, then each stage hands off to the next
+- The orchestrator enforces the topology \u2014 it does NOT improvise
+- Error handling per stage: retry, skip, or escalate
+
+### Phase 3: Design Each Sub-Agent
+
+For each sub-agent, one at a time:
+
+1. **Responsibility** \u2014 One sentence
+2. **System Prompt** \u2014 Role + workflow + constraints
+3. **Middleware** \u2014 Which middleware, and why (include ask_user_to_clarify if this sub-agent needs user approval)
+4. **Input/Output contract** \u2014 What it receives, what it returns
+
+Present each sub-agent design. Get user confirmation before moving to the next.
+
+### Phase 4: Design the Orchestrator
+
+The orchestrator is the parent PROCESSING agent. Use **create_processing_agent** (NOT create_agent):
+
+1. **Responsibility** \u2014 Receive user request, route through the pipeline stages, enforce topology
+2. **System Prompt** \u2014 The defined topology, when to call which sub-agent, error handling
+3. **Topology edges** \u2014 One edge per pipeline stage with a business-meaningful purpose
+4. **Sub-agent list** \u2014 All sub-agents with their role in the pipeline
+
+### Phase 5: Final Review
+
+Before creating, check:
+1. **Completeness** \u2014 Is every stage of the process covered by an edge?
+2. **Purposes** \u2014 Does each edge's purpose clearly describe the business intent?
+3. **Order** \u2014 Is the edge sequence correct?
+4. **Handoffs** \u2014 Is data passed correctly between stages?
+5. **Edge cases** \u2014 What happens on invalid input, stage failure, timeout?
+
+### Creation Order
+
+Always create sub-agents FIRST (via create_agent as react agents), then the orchestrator via create_processing_agent.
+
+\`\`\`
+Creating:
+1. create_agent(name: "stage-1", type: "react", ...)
+2. create_agent(name: "stage-2", type: "react", ...)
+3. create_agent(name: "stage-3", type: "react", ...)
+4. create_processing_agent(
+     name: "orchestrator",
+     prompt: "...",
+     edges: [
+       { from: "orchestrator", to: "stage-1-id", purpose: "Validate and normalize input data" },
+       { from: "stage-1-id", to: "stage-2-id", purpose: "Transform data into target format" },
+       { from: "stage-2-id", to: "stage-3-id", purpose: "Generate final output report" },
+     ],
+     subAgents: ["stage-1-id", "stage-2-id", "stage-3-id"],
+   )
+\`\`\`
+
+**Why serial?** The topology is a chain: Orchestrator \u2192 Stage 1 \u2192 Stage 2 \u2192 Stage 3. Only the first edge's \`from\` references the orchestrator (by name). Subsequent edges chain from the previous sub-agent's ID. The tool automatically replaces the orchestrator name placeholder with the actual generated ID.
+
+---
+
+## Workflow C: Dynamic Agent (DEEP_AGENT type)
+
+Use this for complex, open-ended tasks where the execution path cannot be fully predetermined. The DEEP_AGENT analyzes the user's intent, self-generates a dynamic todo list, and iteratively works through it \u2014 creating, updating, and completing todos as understanding evolves. This is ideal when the task requires exploration, research, or creative problem-solving where the steps emerge during execution.
+
+### Phase 1: Domain Analysis
+
+Ask: What is the overall goal? What makes this complex or open-ended?
+
+Explain why a DEEP_AGENT is the right choice (dynamic decomposition, exploration-driven, adaptive planning).
+
+### Phase 2: Identify Capabilities
+
+Instead of designing a fixed topology, identify what capabilities the agent needs:
+
+\`\`\`
+The agent will need:
+\u251C\u2500\u2500 Capability A: [what the agent must be able to do]
+\u251C\u2500\u2500 Capability B: [what the agent must be able to do]
+\u2514\u2500\u2500 Capability C: [what the agent must be able to do]
+\`\`\`
+
+Each capability maps to middleware or a sub-agent tool.
+
+### Phase 3: Design the Agent
+
+1. **System Prompt** \u2014 Emphasize the dynamic todo-driven workflow. The agent should:
+   - Analyze the user's request and break it into a todo list
+   - Work through todos one at a time
+   - Update and refine the todo list as understanding deepens
+   - Self-correct and adapt based on intermediate findings
+
+2. **Middleware** \u2014 Tools the agent needs:
+   - **filesystem** \u2014 Essential for persistent work
+   - **code_eval** \u2014 If computation or data analysis is needed
+   - **browser** \u2014 If research or web access is needed
+   - **skill** \u2014 If domain-specific workflows are available
+   - **widget** \u2014 If visual output (diagrams, interactive content) is beneficial
+   - **ask_user_to_clarify** \u2014 If the agent needs to confirm actions or ask clarifying questions
+
+3. **Sub-agents** (optional) \u2014 Specialized agents the deep agent can delegate to for specific capabilities
+
+### Phase 4: Final Review
+
+Before creating, check:
+1. **Autonomy** \u2014 Can the agent operate independently?
+2. **Tools** \u2014 Does it have everything needed to self-decompose tasks?
+3. **Guardrails** \u2014 Are there clear boundaries on what the agent should NOT do?
+
+### Creation
+
+\`\`\`
+create_agent(
+  name: "research-agent",
+  type: "deep_agent",
+  prompt: "...",
+  middleware: [...],
+  subAgents: [...]  // optional
+)
+\`\`\`
+
+---
+
+## Editing Existing Agents
+
+When the user wants to modify an agent:
+1. Call **get_agent** to see the current config
+2. Understand what the user wants to change
+3. Present the proposed changes
+4. Call **update_agent** to apply
+
+## Deleting Agents
+
+When the user wants to delete an agent:
+1. Call **get_agent** to show what will be deleted
+2. Warn if this agent is referenced as a sub-agent by others
+3. Ask for explicit confirmation
+4. Call **delete_agent**
+
+## Agent Configuration Reference
+
+### create_agent (REACT and DEEP_AGENT)
+
+All fields except name, type, and prompt are optional.
+
+\`\`\`typescript
+{
+  name: string,              // Required. Display name
+  description?: string,      // Optional. Short description
+  type: "react" | "deep_agent", // Required
+  prompt: string,            // Required. System prompt
+  tools?: string[],          // Optional. Tool keys from list_tools
+  middleware?: MiddlewareConfig[],  // Optional. See middleware reference below
+  subAgents?: string[],      // DEEP_AGENT only. IDs of sub-agents
+  internalSubAgents?: AgentConfig[],    // DEEP_AGENT only. Inline sub-agent configs
+  modelKey?: string,         // Optional. Model to use
+}
+\`\`\`
+
+### create_processing_agent (PROCESSING)
+
+Creates a PROCESSING agent with a business-defined workflow topology. Sub-agents must already exist.
+
+\`\`\`typescript
+{
+  name: string,              // Required. Display name for the orchestrator
+  description?: string,      // Optional. Short description
+  prompt: string,            // Required. System prompt \u2014 how to route through the topology
+  edges: [{                  // Required. At least 1 edge defining the workflow
+    from: string,            // Orchestrator's ID (use placeholder name; tool auto-replaces)
+    to: string,              // Sub-agent ID to delegate to
+    purpose: string,         // Business purpose \u2014 what this step accomplishes
+  }],
+  tools?: string[],          // Optional. Tool keys from list_tools
+  subAgents: string[],       // Required. IDs of sub-agents in the pipeline
+  internalSubAgents?: AgentConfig[],  // Optional. Inline sub-agent configs
+  middleware?: MiddlewareConfig[],    // Optional. Additional middleware (topology is auto-added)
+  modelKey?: string,         // Optional. Model to use
+}
+\`\`\`
+
+### create_processing_agent (PROCESSING)
+
+Creates a PROCESSING agent with a business-defined workflow topology. Sub-agents must already exist.
+
+\`\`\`typescript
+{
+  name: string,              // Required. Display name for the orchestrator
+  description?: string,      // Optional. Short description
+  prompt: string,            // Required. System prompt \u2014 how to route through the topology
+  edges: [{                  // Required. At least 1 edge defining the serial workflow chain
+    from: string,            // Source agent ID. First edge: use orchestrator name as placeholder (tool auto-replaces). Subsequent edges: previous sub-agent ID
+    to: string,              // Sub-agent ID to delegate to
+    purpose: string,         // Business purpose \u2014 what this step accomplishes
+  }],
+  subAgents: string[],       // Required. IDs of sub-agents in the pipeline
+  internalSubAgents?: AgentConfig[],  // Optional. Inline sub-agent configs
+  middleware?: MiddlewareConfig[],    // Optional. Additional middleware (topology is auto-added)
+  modelKey?: string,         // Optional. Model to use
+}
+\`\`\`
+
+### Middleware Config Reference
+
+Each middleware entry uses this base shape:
+
+\`\`\`typescript
+{
+  id: string,          // Unique ID, usually same as type
+  type: string,        // Middleware type from the table below
+  name: string,        // Display name
+  description: string, // What this middleware provides
+  enabled: true,       // Always true for active middleware
+  config: { ... }      // Type-specific config (see table)
+}
+\`\`\`
+
+#### filesystem
+Provides: \`ls\`, \`read_file\`, \`write_file\`, \`edit_file\`, \`glob\`, \`grep\`
+| config field | type | description |
+|-------------|------|-------------|
+| backend | string | Pluggable backend, usually omitted (uses default) |
+| systemPrompt | string? | Custom system prompt override for filesystem conventions |
+
+#### code_eval
+Provides: \`run_code\` \u2014 execute Python/JavaScript in a sandbox
+| config field | type | description |
+|-------------|------|-------------|
+| vmIsolation | "agent" | "project" | "global" | Sandbox isolation level. Default recommended: \`"agent"\` |
+| timeout | number? | Execution timeout in milliseconds |
+| memoryLimit | number? | Memory limit in MB |
+
+#### browser
+Provides: \`browser_navigate\`, \`browser_click\`, \`browser_screenshot\`, \`browser_get_markdown\`, etc. (21 tools)
+| config field | type | description |
+|-------------|------|-------------|
+| vmIsolation | "agent" | "project" | "global" | Sandbox isolation level. Default recommended: \`"agent"\` |
+| headless | boolean? | Whether to run in headless mode |
+
+#### sql
+Provides: \`sql_list_tables\`, \`sql_table_info\`, \`sql_query_checker\`, \`sql_query\`
+| config field | type | description |
+|-------------|------|-------------|
+| databaseKeys | string[] | Array of database config keys to expose. Required. |
+| databaseDescriptions | Record<string,string>? | Optional human-readable descriptions keyed by database key |
+
+#### skill
+Provides: \`load_skill_content\` \u2014 load and read detailed skill instructions
+| config field | type | description |
+|-------------|------|-------------|
+| skills | string[]? | List of specific skill IDs to expose |
+| readAll | boolean? | When \`true\`, all available skills are exposed (recommended) |
+| heading | string? | Optional heading for the skills section |
+| extraNote | string? | Optional extra note appended after skills list |
+
+#### metrics
+Provides: \`list_datasources\`, \`query_metrics_list\`, \`query_semantic_metric_data\`, \`query_tables_list\`, \`execute_sql_query\`, etc. (7 tools)
+| config field | type | description |
+|-------------|------|-------------|
+| serverKeys | string[] | List of metrics server keys. Required. |
+| serverDescriptions | Record<string,string>? | Optional descriptions for each server |
+| connectAll | boolean? | When \`true\`, connects to all available metrics servers automatically |
+
+#### ask_user_to_clarify
+Provides: \`ask_user_to_clarify\` \u2014 pause execution and present questions with predefined options to the user. The agent halts until the user responds, then receives the answers as structured data.
+**Use this when:** the agent needs to confirm an action, get user approval, ask "which one?", or gather missing parameters. Without this middleware, the agent CANNOT interact with the user mid-execution.
+Config: \`{}\` \u2014 no configuration needed.
+
+#### widget
+Provides: \`load_guidelines\`, \`show_widget\` \u2014 render interactive HTML widgets and SVG diagrams
+Config: \`{}\` \u2014 no configuration needed.
+
+#### claw
+Provides: bootstrap file management (AGENTS.md, SOUL.md, etc.) \u2014 injects project context into system prompt
+| config field | type | description |
+|-------------|------|-------------|
+| injectBootstrapFiles | boolean? | Whether to inject bootstrap files into system prompt. Default: \`true\` |
+| bootstrapFiles | object? | Custom content for each bootstrap file |
+
+\`bootstrapFiles\` sub-fields: \`agents\`, \`soul\`, \`identity\`, \`user\`, \`tools\`, \`bootstrap\` \u2014 each is an optional string.
+
+#### date
+Provides: \`get_current_date_time\` \u2014 get current date and time
+| config field | type | description |
+|-------------|------|-------------|
+| timezone | string? | IANA timezone like \`"Asia/Shanghai"\` or \`"America/New_York"\`. Default: \`"UTC"\` |
+
+#### scheduler
+Provides: \`schedule_at\`, \`schedule_after\`, \`schedule_recurring\`, \`cancel_scheduled_task\`, \`list_scheduled_tasks\`
+| config field | type | description |
+|-------------|------|-------------|
+| defaultMaxRetries | number? | Default max retries for scheduled tasks. Default: \`0\` |
+
+#### topology
+Provides: \`read_topo_progress\` \u2014 enforces multi-agent workflow topology. **Required for PROCESSING agents \u2014 auto-injected by create_processing_agent.**
+| config field | type | description |
+|-------------|------|-------------|
+| edges | TopologyEdge[] | **Required.** Directed edges: \`{ from: string, to: string, purpose: string }\`. The \`purpose\` must describe the business intent of this delegation step. |
+| trackingStore | object? | Optional persistence for workflow run tracking | |
+
+### When to use ask_user_to_clarify Middleware
+
+**CRITICAL: Always add this middleware when the agent needs user confirmation, approval, or clarification.** Without it, the agent cannot interact with the user during execution.
+
+**Required scenarios:**
+- Confirming irreversible actions (delete data, send emails, make purchases, modify production configs)
+- Asking the user to choose between options (e.g., "Which database?", "Which report format?")
+- Gathering missing parameters the user didn't provide upfront
+- Requesting user approval before proceeding to a critical step
+- Disambiguating vague user requests before acting
+
+**Tool capabilities:**
+| Feature | Description |
+|---------|-------------|
+| Single choice | User picks ONE option from a list (e.g., "Choose environment: [production] [staging]") |
+| Multiple choice | User picks SEVERAL options (e.g., "Select reports: [sales] [inventory] [hr]") |
+| Required | Forces the user to answer before the agent continues |
+| allowOther | Lets the user type a custom answer beyond listed options |
+
+**Design rule:** If your agent's system prompt says anything like "confirm with the user before...", "ask the user to choose...", or "get approval for...", you MUST include the \`ask_user_to_clarify\` middleware.
+
+### Quick Pick: Common Middleware Combos
+
+| Agent Role | Recommended Middleware |
+|-----------|----------------------|
+| Code assistant | filesystem, code_eval, widget |
+| Data analyst | filesystem, sql, code_eval, widget |
+| Web researcher | browser, filesystem, widget |
+| Operations / SRE | metrics, sql, widget |
+| Process orchestrator | skill, date, scheduler, widget |
+| General assistant | filesystem, date, widget |
+| Approval-gated operations | ask_user_to_clarify, filesystem, widget |
+| Interactive Q&A | ask_user_to_clarify, date, widget |
+
+### update_processing_agent
+
+Updates a PROCESSING agent's topology edges, name, prompt, or sub-agents. Unlike update_agent, this properly handles placeholder resolution for edge \`from\` values and manages the topology middleware correctly.
+
+\`\`\`typescript
+{
+  id: string,                // Required. The PROCESSING agent ID to update
+  name?: string,             // Optional. New display name
+  description?: string,      // Optional. New short description
+  prompt?: string,           // Optional. New orchestrator system prompt
+  edges?: [{                 // Optional. New topology edges (serial chain)
+    from: string,            // First edge: orchestrator name placeholder. Subsequent: previous sub-agent ID
+    to: string,              // Sub-agent ID
+    purpose: string,         // Business purpose
+  }],
+  subAgents?: string[],      // Optional. New sub-agent IDs
+  middleware?: MiddlewareConfig[],  // Optional. Additional middleware (topology auto-managed)
+  modelKey?: string,         // Optional. New model
+}
+\`\`\`
+
+**When to use:** Use this whenever you need to change a PROCESSING agent's topology \u2014 adding/removing/recruiting pipeline stages, changing the flow order, or updating edge purposes. Use regular \`update_agent\` only for REACT and DEEP_AGENT agents.
+
+### update_agent parameters
+
+\`\`\`typescript
+{
+  id: string,                // Required. Agent ID to update
+  config: {                  // Required. Full or partial agent config
+    name?: string,
+    description?: string,
+    prompt?: string,
+    middleware?: [...],
+    // ... any other fields
+  }
+}
+\`\`\`
+`;
+
+// src/agent_lattice/agentArchitectConfig.ts
+var AGENT_ARCHITECT_KEY = "agent-architect";
+var agentArchitectConfig = {
+  key: AGENT_ARCHITECT_KEY,
+  name: "Agent Architect",
+  description: "Design and manage AI agents through natural language conversation. Use this agent when you want to create a new agent, modify an existing agent, or manage your agent collection (list, view, update, delete).",
+  type: AgentType3.DEEP_AGENT,
+  prompt: AGENT_ARCHITECT_PROMPT,
+  tools: [
+    "list_agents",
+    "list_tools",
+    "get_agent",
+    "create_agent",
+    "create_processing_agent",
+    "update_processing_agent",
+    "update_agent",
+    "delete_agent",
+    "invoke_agent"
+  ],
+  middleware: [
+    {
+      id: "widget",
+      type: "widget",
+      name: "Widget",
+      description: "Render interactive HTML widgets and SVG diagrams",
+      enabled: true,
+      config: {}
+    }
+  ]
+};
+
+// src/agent_lattice/builtinAgents.ts
+var BUILTIN_AGENTS = [agentArchitectConfig];
+function ensureBuiltinAgentsForTenant(tenantId) {
+  for (const config of BUILTIN_AGENTS) {
+    if (!agentLatticeManager.hasWithTenant(tenantId, config.key)) {
+      agentLatticeManager.registerLatticeWithTenant(tenantId, config);
+    }
+  }
+}
+
 // src/agent_lattice/AgentLatticeManager.ts
 function assistantToConfig(assistant) {
   const graphDef = typeof assistant.graphDefinition === "object" && assistant.graphDefinition !== null ? assistant.graphDefinition : {};
@@ -16943,6 +19137,7 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
    * @param tenantId 租户ID
    */
   async initializeStoredAssistantsForTenant(tenantId) {
+    ensureBuiltinAgentsForTenant(tenantId);
     try {
       const storeLattice = getStoreLattice("default", "assistant");
       const assistants = await storeLattice.store.getAllAssistants(tenantId);
@@ -18162,10 +20357,10 @@ var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
     }
     const tools = await this.getAllTools();
     console.log(`[MCP] Registering ${tools.length} tools to Tool Lattice...`);
-    for (const tool50 of tools) {
-      const toolKey = prefix ? `${prefix}_${tool50.name}` : tool50.name;
-      tool50.name = toolKey;
-      toolLatticeManager.registerExistingTool(toolKey, tool50);
+    for (const tool51 of tools) {
+      const toolKey = prefix ? `${prefix}_${tool51.name}` : tool51.name;
+      tool51.name = toolKey;
+      toolLatticeManager.registerExistingTool(toolKey, tool51);
       console.log(`[MCP] Registered tool: ${toolKey}`);
     }
     console.log(`[MCP] Successfully registered ${tools.length} tools to Tool Lattice`);
@@ -18463,7 +20658,7 @@ function parseOptionalNumberEnv(name, fallback) {
 }
 function getDefaultMicrosandboxRemoteConfig() {
   return {
-    image: process.env.MICROSANDBOX_IMAGE ?? "daytona-cn-shanghai.cr.volces.com/daytona/sandbox:0.0.4",
+    image: process.env.MICROSANDBOX_IMAGE ?? "daytona-cn-shanghai.cr.volces.com/daytona/sandbox:0.0.5",
     //"daytonaio/sandbox:0.6.0",
     cpus: parseOptionalNumberEnv("MICROSANDBOX_CPUS", 1),
     memoryMib: parseOptionalNumberEnv("MICROSANDBOX_MEMORY", 512),
@@ -19328,6 +21523,7 @@ export {
   AgentLatticeManager,
   AgentManager,
   AgentType,
+  BUILTIN_SKILLS,
   ChunkBuffer,
   ChunkBufferLatticeManager,
   CompositeBackend,
@@ -19411,6 +21607,7 @@ export {
   createListMetricsServersTool,
   createListTablesSqlTool,
   createModelSelectorMiddleware,
+  createProcessingAgent,
   createQueryCheckerSqlTool,
   createQueryMetricDefinitionTool,
   createQueryMetricsListTool,
@@ -19438,7 +21635,11 @@ export {
   getAgentClient,
   getAgentConfig,
   getAllAgentConfigs,
+  getAllBuiltInSkillMetas,
   getAllToolDefinitions,
+  getBuiltInSkillContent,
+  getBuiltInSkillMeta,
+  getBuiltInSkillNames,
   getCheckpointSaver,
   getChunkBuffer,
   getEmbeddingsClient,
@@ -19460,6 +21661,7 @@ export {
   grepMatchesFromFiles,
   grepSearchFiles,
   hasChunkBuffer,
+  isBuiltInSkill,
   isUsingDefaultKey,
   isValidCronExpression,
   isValidSandboxName,