n8n 2.31.5 → 2.32.1

package/dist/modules/agents/builder/skills/mcp.skill.js

@@ -11,20 +11,25 @@ function mcpSkill() {
         name: 'Agent builder MCP servers',
         description: 'Use when adding, removing, or updating MCP (Model Context Protocol) servers on the target agent.',
         recommendedTools: [
-            'search_mcp_servers',
+            'resolve_integration',
+            'ask_questions',
             'ask_credential',
             'verify_mcp_server',
             'read_config',
             'patch_config',
         ],
         allowedTools: [
+            'resolve_integration',
             'search_mcp_servers',
+            'search_nodes',
+            'get_node_types',
             'ask_credential',
             'verify_mcp_server',
             'ask_questions',
             'read_config',
             'patch_config',
             'write_config',
+            'load_skill',
         ],
         instructions: `\
 ## Purpose
@@ -36,30 +41,57 @@ connected MCP server.
 
 ## Use when:
 
-- The user asks for an external integration and you need to discover/connect an MCP server for it.
-- The user asks to edit the target agent's MCP servers.
-- The users wants to add a custom MCP server.
+- \`resolve_integration\` returned \`kind: "mcp"\`.
+- The user explicitly asks to add or edit an MCP server.
+- The user provides or asks to configure a custom MCP server.
 
 ## Workflow
 
 ### Discovery and setup
 
-Follow these steps in order when adding an MCP server:
-
-1. Search: call \`search_mcp_servers\` with queries matching the requested
-   integration (for example \`["github"]\`, \`["slack"]\`).
-   The result includes \`name\`, \`url\`, \`transport\`, \`authentication\`,
-   \`credentialType\`, \`tools\`, and optional \`metadata\`.
-2. Credential: for registry results, call \`ask_credential\` with the returned
-   \`credentialType\`. Never invent credential IDs.
-3. Verify: call \`verify_mcp_server\` with \`name\`, \`url\`, \`transport\`,
-   \`authentication\`, and (if applicable) \`credential\`.
-4. Write config: call \`read_config\`, then \`patch_config\` to add the entry
-   to \`mcpServers[]\` using the patch pattern below.
-
-If \`search_mcp_servers\` returns no matches and the user provides a custom
-server URL, skip the search result mapping and continue with manual
-transport/authentication plus credential selection.
+For a generic external-service request, \`resolve_integration\` must select the
+integration type before this skill is loaded. If no resolver result is
+available yet, call \`resolve_integration\` with queries matching the requested
+service. Resolve one requested service per call; use \`queries\` only for
+alternative search terms for that service.
+
+- If it returns \`kind: "node"\` for a generic service request, load
+  \`agent-builder-node-tools\` and continue with the returned node results. Stop
+  this MCP workflow.
+- If it returns \`kind: "node"\` but the user explicitly requested an MCP server,
+  do not silently substitute a node tool. Continue with manual MCP setup by
+  asking for the URL and transport/authentication decision through
+  \`${api_types_1.ASK_QUESTIONS_TOOL_NAME}\`.
+- \`resolve_integration\` returns \`{ kind: "mcp", results: [...] }\` for MCP
+  matches. Never read server fields from the wrapper; select a result first:
+  - If \`results[]\` contains one entry, use it as \`selectedResult\`.
+  - If the request uniquely identifies one entry by \`name\` or \`title\`, use
+    that entry as \`selectedResult\`.
+  - If multiple candidates remain, call \`ask_questions\` with the candidate
+    titles and descriptions; never choose by array order. Use the chosen entry
+    as \`selectedResult\`. If \`ask_questions\` returns \`{ answered: false }\`,
+    stop MCP setup without selecting a server, asking for credentials, verifying
+    a connection, or mutating config. Do not re-present the question.
+- Use \`name\`, \`url\`, \`transport\`, \`authentication\`, \`credentialType\`,
+  \`tools\`, and optional \`metadata\` only from \`selectedResult\`.
+
+Follow these steps for the selected MCP result:
+
+1. Credential: call \`ask_credential\` with a short \`purpose\`, using
+   \`selectedResult.credentialType\` as \`credentialType\`. Never invent
+   credential IDs.
+2. Verify: call \`verify_mcp_server\` with the selected result's \`name\`, \`url\`,
+   \`transport\`, and \`authentication\`, plus the returned \`credentialId\` as
+   \`credential\` when authentication is required.
+3. Capability check: confirm the verified tool names and descriptions cover the
+   capability the user requested.
+4. Write config: call \`read_config\`, then \`patch_config\` to add the entry to
+   \`mcpServers[]\` using the patch pattern below.
+
+If verification succeeds but the tools do not cover the requested capability
+for a generic service request, load \`agent-builder-node-tools\`, call
+\`search_nodes\` with the same service queries, and continue with node setup. Do
+not add the MCP server merely because its registry entry matched.
 
 Full schema reference:
 
@@ -75,8 +107,6 @@ ${mcpServerSchemaText}
   \`credentialType: "httpMultipleHeadersAuth"\`.
 - For \`mcpOAuth2Api\`, call \`ask_credential\` with
   \`credentialType: "mcpOAuth2Api"\`.
-- Never invent credential IDs. If the user declines, omit the server entirely
-  rather than persisting a stub.
 
 ### Testing the connection
 
@@ -91,10 +121,25 @@ Before writing to config, call \`verify_mcp_server\` with server \`name\`,
 - If verification fails, explain the error and ask the user to check the URL
   or credentials before proceeding.
 
+### Incomplete setup
+
+The user can skip the credential prompt, the URL question, or both. Never
+invent a credential ID or a placeholder URL to fill the gap, and never abort
+the server addition — always persist what is known and let the user finish
+setup later:
+
+- Credential skipped (\`ask_credential\` returned \`{ skipped: true }\`): omit
+  only the \`credential\` field.
+- URL skipped: persist \`url: ""\`.
+- Either case: skip \`verify_mcp_server\` (there is nothing to authenticate or
+  connect to), then \`read_config\` and \`patch_config\` the entry, preserving
+  every other known field — \`name\`, \`transport\`, \`authentication\`, an
+  already-selected credential, and registry \`metadata\`.
+
 ### Selecting credentials
 
 When using a registry-backed server, always use the \`credentialType\` returned
-by \`search_mcp_servers\`.
+by \`selectedResult\`.
 
 For custom MCP servers, if credential type is unknown, ask the user which
 credential type to use (OAuth2, Bearer Token, Header Auth, Multiple Headers
@@ -116,11 +161,12 @@ Auth, or None) via \`${api_types_1.ASK_QUESTIONS_TOOL_NAME}\`. Then map to:
 ## Gotchas
 
 - Server \`name\` must be unique across \`mcpServers\` within an agent.
-- Never invent credential IDs. If the user declines, omit the server entirely.
 - Never fabricate \`metadata.nodeTypeName\`.
-- When \`search_mcp_servers\` returns \`metadata.nodeTypeName\`, include
-  \`metadata: { nodeTypeName: <result.nodeTypeName> }\` in the entry so the UI
-  can render the correct server form.`,
+- When \`selectedResult\` includes \`metadata.nodeTypeName\`, include
+  \`metadata: { nodeTypeName: <selectedResult.metadata.nodeTypeName> }\` in the
+  entry so the UI can render the correct server form.
+- A registry match proves server availability, not support for the requested
+  capability; use the verified live tool list for that decision.`,
     };
 }
 //# sourceMappingURL=mcp.skill.js.map

package/dist/modules/agents/builder/skills/mcp.skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"mcp.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/mcp.skill.ts"],"names":[],"mappings":";;AAWA,4BAsHC;AAhID,8CAAgF;AAEhF,2DAAqD;AAErD,qFAAmF;AAEnF,MAAM,mBAAmB,GAAG,IAAA,gDAAuB,EAClD,IAAA,oCAAe,EAAC,iCAAqB,CAAgB,CACrD,CAAC;AAEF,SAAgB,QAAQ;IACvB,OAAO;QACN,EAAE,EAAE,mBAAmB;QACvB,IAAI,EAAE,2BAA2B;QACjC,WAAW,EACV,kGAAkG;QACnG,gBAAgB,EAAE;YACjB,oBAAoB;YACpB,gBAAgB;YAChB,mBAAmB;YACnB,aAAa;YACb,cAAc;SACd;QACD,YAAY,EAAE;YACb,oBAAoB;YACpB,gBAAgB;YAChB,mBAAmB;YACnB,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;SACd;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqCd,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAmCE,mCAAuB;;;;;;;;;;;;;;;;;;;;;;sCAsBR;KACpC,CAAC;AACH,CAAC"}
+{"version":3,"file":"mcp.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/mcp.skill.ts"],"names":[],"mappings":";;;AACA,8CAAgF;AAEhF,2DAAqD;AAErD,qFAAmF;AAEnF,MAAM,mBAAmB,GAAG,IAAA,gDAAuB,EAClD,IAAA,oCAAe,EAAC,iCAAqB,CAAgB,CACrD,CAAC;AAEF;IACC,OAAO;QACN,EAAE,EAAE,mBAAmB;QACvB,IAAI,EAAE,2BAA2B;QACjC,WAAW,EACV,kGAAkG;QACnG,gBAAgB,EAAE;YACjB,qBAAqB;YACrB,eAAe;YACf,gBAAgB;YAChB,mBAAmB;YACnB,aAAa;YACb,cAAc;SACd;QACD,YAAY,EAAE;YACb,qBAAqB;YACrB,oBAAoB;YACpB,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,mBAAmB;YACnB,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;YACd,YAAY;SACZ;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8BV,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkC3B,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAgDE,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;iEAuBmB;KAC/D,CAAC;AACH,CAAC"}

package/dist/modules/agents/builder/skills/memory.skill.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeSkill } from '@n8n/agents';
+export declare function memorySkill(): RuntimeSkill;

package/dist/modules/agents/builder/skills/memory.skill.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memorySkill = memorySkill;
+function memorySkill() {
+    return {
+        id: 'agent-builder-memory',
+        name: 'Agent Builder Memory',
+        description: 'Use for explicit memory changes: Episodic/long-term/cross-session memory, observer/reflector/extractor worker models, threshold/budget tuning, or disabling memory. Not for ordinary fresh-agent creation, which uses the default memory config in Memory Guidance.',
+        recommendedTools: [
+            'ask_embedding_credential',
+            'resolve_llm',
+            'ask_credential',
+            'read_config',
+            'patch_config',
+        ],
+        allowedTools: [
+            'ask_embedding_credential',
+            'resolve_llm',
+            'ask_credential',
+            'ask_questions',
+            'read_config',
+            'patch_config',
+            'write_config',
+        ],
+        instructions: `\
+## Purpose
+
+Use this to tune or disable the target agent's memory, or to enable Episodic
+Memory (long-term, cross-session recall).
+
+## Use when
+
+- The user asks to enable, configure, or disable Episodic Memory, long-term
+  memory, prior conversations, remembered decisions, exact artifacts, or
+  cross-session memory.
+- The user asks to tune observer/reflector/extractor worker models, token
+  thresholds, render budgets, or the observation log tail limit.
+- The user asks to disable session memory or observational memory.
+
+## Observational Memory Tuning
+
+- Supported observational memory tuning fields: \`enabled\`, \`observerModel\`, \`reflectorModel\`, \`observerThresholdTokens\`, \`reflectorThresholdTokens\`, \`renderTokenBudget\`, \`observationLogTailLimit\`, and \`lockTtlMs\`.
+- Memory worker model fields must use object shape: \`{ "model": "provider/model-name", "credential": "<credentialId>" }\`.
+- Only set \`observerModel\`, \`reflectorModel\`, \`extractorModel\`, or \`episodicMemory.reflectorModel\` when the user explicitly asks to use a specific model for memory work.
+- Use only credential IDs returned by \`resolve_llm\` or \`ask_credential\` for memory worker model fields. Do not invent IDs or copy a main-model credential unless one of those tools returned it for that worker model provider.
+
+## Episodic Memory
+
+- Enable \`memory.episodicMemory\` only when the user asks for Episodic Memory, long-term memory, prior conversations, remembered decisions, exact artifacts, or cross-session memory.
+- Before enabling it, call \`ask_embedding_credential({ credentialType: "openAiApi", purpose: "OpenAI credential for Episodic Memory embeddings" })\`.
+- On success, set \`memory.episodicMemory = { "enabled": true, "credential": "<credentialId>" }\`, using the returned \`credentialId\` value. This can be a real credential id or \`"managed"\` when the assistant proxy is available. Preserve existing \`topK\` or \`maxEntriesPerRun\`.
+- \`memory.episodicMemory.credential\` is only for OpenAI embeddings. It is separate from optional \`extractorModel\` and \`reflectorModel\` worker credentials.
+- If credential selection is skipped, do not enable Episodic Memory; explain that it needs an OpenAI credential for embeddings.
+- Do not add instructions saying the agent should remember, store, save, or decide what context matters. The runtime handles memory extraction and indexing.
+- If instructions mention Episodic Memory, phrase it as retrieval/use only, e.g. "Use recalled prior context when relevant to the user's request."
+- Do not invent Episodic Memory credential IDs or reuse the main model credential unless \`ask_embedding_credential\` returned it for this purpose.
+
+## Gotchas
+
+- Session memory and Episodic Memory are different features; do not use one as a substitute for the other.
+- Observational memory is runtime-managed session memory behavior; do not add target-agent instructions telling it how to save observations.
+- A skipped Episodic Memory credential means Episodic Memory stays disabled.
+
+## Verify
+
+- Episodic Memory has an OpenAI credential or \`"managed"\` returned by \`ask_embedding_credential\`.
+- Existing memory tuning is preserved unless the user asked to change it.`,
+    };
+}
+//# sourceMappingURL=memory.skill.js.map

package/dist/modules/agents/builder/skills/memory.skill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/memory.skill.ts"],"names":[],"mappings":";;;AAEA;IACC,OAAO;QACN,EAAE,EAAE,sBAAsB;QAC1B,IAAI,EAAE,sBAAsB;QAC5B,WAAW,EACV,qQAAqQ;QACtQ,gBAAgB,EAAE;YACjB,0BAA0B;YAC1B,aAAa;YACb,gBAAgB;YAChB,aAAa;YACb,cAAc;SACd;QACD,YAAY,EAAE;YACb,0BAA0B;YAC1B,aAAa;YACb,gBAAgB;YAChB,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;SACd;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EA0C0D;KACxE,CAAC;AACH,CAAC"}

package/dist/modules/agents/builder/skills/node-tools.skill.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeSkill } from '@n8n/agents';
+export declare function nodeToolsSkill(): RuntimeSkill;

package/dist/modules/agents/builder/skills/node-tools.skill.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeToolsSkill = nodeToolsSkill;
+function nodeToolsSkill() {
+    return {
+        id: 'agent-builder-node-tools',
+        name: 'Agent Builder Node Tools',
+        description: 'Use when resolve_integration returns kind: "node" or the user explicitly requests an n8n node-backed tool: search_nodes/get_node_types discovery, nodeParameters, node credential slots, $fromAI usage, or other n8n expressions.',
+        recommendedTools: [
+            'resolve_integration',
+            'search_nodes',
+            'get_node_types',
+            'ask_credential',
+            'read_config',
+            'patch_config',
+        ],
+        allowedTools: [
+            'resolve_integration',
+            'search_nodes',
+            'get_node_types',
+            'ask_credential',
+            'get_resource_locator_options',
+            'ask_questions',
+            'read_config',
+            'patch_config',
+            'write_config',
+            'load_skill',
+        ],
+        instructions: `\
+## Purpose
+
+Use this to discover, configure, and wire node tools into the target agent's
+\`tools[]\`, including \`nodeParameters\` and n8n expressions.
+
+## Workflow
+
+- For a generic external-service request, call \`resolve_integration\` before
+  node discovery unless a resolver result is already available.
+- If it returns \`kind: "mcp"\`, load \`agent-builder-mcp\` and stop this node-tool
+  workflow.
+- If it returns \`kind: "node"\`, use its returned node results and call
+  \`get_node_types\`; do not repeat the same search with \`search_nodes\`.
+- Call \`search_nodes\` directly only when the user explicitly requests an n8n
+  node, when refining node results, or when a verified MCP server lacks the
+  requested capability.
+- Never guess node type names.
+- Use the tool node id from discovery, usually ending in \`Tool\`.
+- Put fixed values in \`nodeParameters\`; use complete n8n expressions for values the agent should decide at runtime:
+  \`={{ $fromAI('url', 'The URL to inspect', 'string') }}\`.
+- For stable dynamic selectors, load \`agent-builder-resource-locators\` and
+  follow it.
+- Never write literal \`"$fromAI"\` or bare \`$fromAI\`; the node will treat it as the actual value.
+- Do not pipe AI-chosen fields through \`$json\`.
+- Do not include \`inputSchema\` or \`toolDescription\` for node tools.
+- For each required credential slot, call \`ask_credential\` once before config mutation. Pass the node's credential key as \`credentialSlot\`. On success, copy the returned \`credentials\` object directly to \`node.credentials\`. If skipped, still add the tool and omit only that credential slot.
+
+## n8n Expressions
+
+Node tool parameters inside \`nodeParameters\` can use n8n expressions.
+Prefer \`$fromAI\` whenever the target agent should decide a value at runtime.
+Do not use \`$fromAI\` for stable resource IDs that the target agent cannot know
+at runtime, such as Linear \`teamId\`, project IDs, channel IDs, calendar IDs,
+database IDs, table IDs, or other dynamic "Name or ID" selectors. Resolve those
+with the \`agent-builder-resource-locators\` skill, \`ask_credential\`, and
+\`get_resource_locator_options\`; write the returned \`parameterValue\` into
+\`nodeParameters\`.
+
+- \`={{ /*n8n-auto-generated-fromAI-override*/ $fromAI('fieldName', 'What value to provide', 'string') }}\`
+- \`={{ /*n8n-auto-generated-fromAI-override*/ $fromAI('count', 'How many items', 'number') }}\`
+- \`={{ /*n8n-auto-generated-fromAI-override*/ $fromAI('enabled', 'Whether to enable this option', 'boolean') }}\`
+- \`={{ $now.toISO() }}\` for current date/time.
+- \`={{ $today }}\` for the start of today.
+
+Always wrap expressions in \`={{ }}\`. Never pipe AI-chosen node-tool fields
+through \`$json\`; use \`$fromAI\` for those fields instead.
+
+## Gotchas
+
+- Do not include \`inputSchema\` or \`toolDescription\` for node tools.
+- \`$fromAI(...)\` placeholders define the node tool input schema; do not add it manually.
+- Follow \`agent-builder-resource-locators\` for dynamic selector lookup,
+  credentials, and \`parameterValue\` handling.
+- If a required node-tool credential is skipped, add the tool and omit only that credential slot.
+
+## Verify
+
+- Node tools use discovered tool node ids and valid node parameters.`,
+    };
+}
+//# sourceMappingURL=node-tools.skill.js.map

package/dist/modules/agents/builder/skills/node-tools.skill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-tools.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/node-tools.skill.ts"],"names":[],"mappings":";;;AAEA;IACC,OAAO;QACN,EAAE,EAAE,0BAA0B;QAC9B,IAAI,EAAE,0BAA0B;QAChC,WAAW,EACV,mOAAmO;QACpO,gBAAgB,EAAE;YACjB,qBAAqB;YACrB,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,aAAa;YACb,cAAc;SACd;QACD,YAAY,EAAE;YACb,qBAAqB;YACrB,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,8BAA8B;YAC9B,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;YACd,YAAY;SACZ;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEA0DqD;KACnE,CAAC;AACH,CAAC"}

package/dist/modules/agents/builder/skills/research.skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"research.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/research.skill.ts"],"names":[],"mappings":";;AAEA,sCAyCC;AAzCD,SAAgB,aAAa;IAC5B,OAAO;QACN,EAAE,EAAE,wBAAwB;QAC5B,IAAI,EAAE,wBAAwB;QAC9B,WAAW,EACV,yNAAyN;QAC1N,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+EAiC+D;KAC7E,CAAC;AACH,CAAC"}
+{"version":3,"file":"research.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/research.skill.ts"],"names":[],"mappings":";;;AAEA;IACC,OAAO;QACN,EAAE,EAAE,wBAAwB;QAC5B,IAAI,EAAE,wBAAwB;QAC9B,WAAW,EACV,yNAAyN;QAC1N,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+EAiC+D;KAC7E,CAAC;AACH,CAAC"}

package/dist/modules/agents/builder/skills/resource-locators.skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"resource-locators.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/resource-locators.skill.ts"],"names":[],"mappings":";;AAEA,sDAyHC;AAzHD,SAAgB,qBAAqB;IACpC,OAAO;QACN,EAAE,EAAE,iCAAiC;QACrC,IAAI,EAAE,iCAAiC;QACvC,WAAW,EACV,wTAAwT;QACzT,gBAAgB,EAAE;YACjB,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,8BAA8B;YAC9B,aAAa;YACb,cAAc;SACd;QACD,YAAY,EAAE;YACb,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,8BAA8B;YAC9B,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;SACd;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDA+FoC;KAClD,CAAC;AACH,CAAC"}
+{"version":3,"file":"resource-locators.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/resource-locators.skill.ts"],"names":[],"mappings":";;;AAEA;IACC,OAAO;QACN,EAAE,EAAE,iCAAiC;QACrC,IAAI,EAAE,iCAAiC;QACvC,WAAW,EACV,wTAAwT;QACzT,gBAAgB,EAAE;YACjB,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,8BAA8B;YAC9B,aAAa;YACb,cAAc;SACd;QACD,YAAY,EAAE;YACb,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,8BAA8B;YAC9B,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;SACd;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDA+FoC;KAClD,CAAC;AACH,CAAC"}

package/dist/modules/agents/builder/skills/sub-agents.skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"sub-agents.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/sub-agents.skill.ts"],"names":[],"mappings":";;AAOA,wCA4HC;AAlID,8CAIwB;AAExB,SAAgB,cAAc;IAC7B,OAAO;QACN,EAAE,EAAE,0BAA0B;QAC9B,IAAI,EAAE,0BAA0B;QAChC,WAAW,EACV,iKAAiK;QAClK,gBAAgB,EAAE,CAAC,iBAAiB,EAAE,eAAe,EAAE,aAAa,EAAE,cAAc,CAAC;QACrF,YAAY,EAAE;YACb,iBAAiB;YACjB,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;SACd;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;sDAuBsC,sCAA0B,OAAO,sCAA0B,gCAAgC,0CAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAqF1H,sCAA0B,OAAO,sCAA0B,GAAG;KACjH,CAAC;AACH,CAAC"}
+{"version":3,"file":"sub-agents.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/sub-agents.skill.ts"],"names":[],"mappings":";;;AACA,8CAIwB;AAExB;IACC,OAAO;QACN,EAAE,EAAE,0BAA0B;QAC9B,IAAI,EAAE,0BAA0B;QAChC,WAAW,EACV,iKAAiK;QAClK,gBAAgB,EAAE,CAAC,iBAAiB,EAAE,eAAe,EAAE,aAAa,EAAE,cAAc,CAAC;QACrF,YAAY,EAAE;YACb,iBAAiB;YACjB,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;SACd;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;sDAuBsC,sCAA0B,OAAO,sCAA0B,gCAAgC,0CAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAqF1H,sCAA0B,OAAO,sCAA0B,GAAG;KACjH,CAAC;AACH,CAAC"}

package/dist/modules/agents/builder/skills/target-skills.skill.js

@@ -6,9 +6,9 @@ function targetSkillsSkill() {
     return {
         id: 'agent-builder-target-skills',
         name: 'Agent Builder Target Skills',
-        description: 'Use when creating reusable target-agent skills, playbooks, policies, style guides, or domain instructions with create_skill that should load only for relevant future requests; not for builder guidance or one-off instructions.',
-        recommendedTools: ['create_skill', 'ask_questions', 'read_config', 'patch_config'],
-        allowedTools: ['create_skill', 'ask_questions', 'read_config', 'patch_config', 'write_config'],
+        description: 'Use when creating reusable target-agent skills, playbooks, policies, style guides, or domain instructions with create_skills that should load only for relevant future requests; not for builder guidance or one-off instructions.',
+        recommendedTools: ['create_skills', 'ask_questions', 'read_config', 'patch_config'],
+        allowedTools: ['create_skills', 'ask_questions', 'read_config', 'patch_config', 'write_config'],
         instructions: `\
 ## Purpose
 
@@ -40,7 +40,7 @@ ${skill_body_template_1.SKILL_BODY_TEMPLATE}
 
 ## Ask first (required)
 
-Do NOT call \`create_skill\` until you have enough concrete domain detail to write
+Do NOT call \`create_skills\` until you have enough concrete domain detail to write
 a genuinely useful skill: a specific routing description and a body whose
 applicable sections are filled with real content (the actual steps, rules,
 examples, and edge cases). If any of that is missing, ask the user clarifying
@@ -52,14 +52,20 @@ write it. Never create a placeholder or vague skill.
 
 - Gather the domain detail you need, asking clarifying questions until the
   description and every applicable body section can be written with concrete
-  content.
-- Write the \`description\` as the routing contract and \`instructions\` using the
-  template above. Put all "when to use" / "when not to use" guidance in the
-  description, never in the body (the body is invisible until the skill loads).
-- Call \`create_skill\` with \`name\`, \`description\`, and \`instructions\`.
-- \`create_skill\` stores the skill only; it does not attach the skill.
-- After it returns an id, call \`read_config\`.
-- Use \`patch_config\` or \`write_config\` to add \`{ "type": "skill", "id": "<returned id>" }\` to \`skills\`.
+  content, for every skill you plan to create.
+- Write each skill's \`description\` as the routing contract and \`instructions\`
+  using the template above. Put all "when to use" / "when not to use" guidance
+  in the description, never in the body (the body is invisible until the skill
+  loads).
+- Call \`create_skills\` once with a \`skills\` array containing every skill you
+  currently know how to write — do not spread multiple fully-specified skills
+  across separate calls. A single skill is still a one-item array.
+- \`create_skills\` stores the skill bodies only; it does not attach them. The
+  batch is all-or-nothing: an invalid or duplicate-named skill rejects the
+  whole call.
+- After it returns an id per skill, call \`read_config\`.
+- Use \`patch_config\` or \`write_config\` to add a \`{ "type": "skill", "id": "<returned id>" }\`
+  entry per skill to \`skills\`.
 
 ## Extended fields
 
@@ -76,7 +82,7 @@ write it. Never create a placeholder or vague skill.
   \`references/intake-checklist.md\`".
 - Omit fields you cannot fill confidently. Do not invent tool names or file paths.
 - Scripts are not supported in this phase. Do not pass scripts or non-markdown
-  linked files to \`create_skill\`.
+  linked files to \`create_skills\`.
 
 ## Rules
 
@@ -86,20 +92,23 @@ write it. Never create a placeholder or vague skill.
 - Do not rely on a body "Use when" section to trigger the skill; the body is
   not visible until after the skill is selected.
 - Include concrete gotchas that prevent predictable target-agent mistakes.
-- Do not use \`create_skill\` for builder instructions. These skills belong to the target agent.
+- Do not use \`create_skills\` for builder instructions. These skills belong to the target agent.
 
 ## Gotchas
 
-- \`create_skill\` does not attach the skill to the target agent config.
+- \`create_skills\` does not attach any skill to the target agent config.
 - A skill that is useful for every request probably belongs in instructions, not in \`skills\`.
 - A vague description creates a vague skill, even if the body is excellent.
 - Do not create placeholder or vague skills; ask for missing domain details first.
+- Do not call \`create_skills\` once per skill when several are ready — batch them
+  into one call so the whole set is stored in a single round trip.
 
 ## Verify
 
-- The returned skill id is attached in config as \`{ "type": "skill", "id": "<returned id>" }\`.
-- The skill description clearly states when it should load.
-- The body follows the template, with each applicable section filled with
+- Every returned skill id is attached in config as a \`{ "type": "skill", "id": "<returned id>" }\`
+  entry.
+- Each skill description clearly states when it should load.
+- Each body follows the template, with each applicable section filled with
   concrete content (no placeholders), and tells the target agent what to do when
   the skill is loaded.`,
     };

package/dist/modules/agents/builder/skills/target-skills.skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"target-skills.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/target-skills.skill.ts"],"names":[],"mappings":";;AAQA,8CAsGC;AA5GD,gEAIgC;AAEhC,SAAgB,iBAAiB;IAChC,OAAO;QACN,EAAE,EAAE,6BAA6B;QACjC,IAAI,EAAE,6BAA6B;QACnC,WAAW,EACV,mOAAmO;QACpO,gBAAgB,EAAE,CAAC,cAAc,EAAE,eAAe,EAAE,aAAa,EAAE,cAAc,CAAC;QAClF,YAAY,EAAE,CAAC,cAAc,EAAE,eAAe,EAAE,aAAa,EAAE,cAAc,EAAE,cAAc,CAAC;QAC9F,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;EAqBd,4CAAsB;;;;EAItB,4CAAsB;;EAEtB,yCAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAiEE;KACrB,CAAC;AACH,CAAC"}
+{"version":3,"file":"target-skills.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/target-skills.skill.ts"],"names":[],"mappings":";;;AAEA,gEAIgC;AAEhC;IACC,OAAO;QACN,EAAE,EAAE,6BAA6B;QACjC,IAAI,EAAE,6BAA6B;QACnC,WAAW,EACV,oOAAoO;QACrO,gBAAgB,EAAE,CAAC,eAAe,EAAE,eAAe,EAAE,aAAa,EAAE,cAAc,CAAC;QACnF,YAAY,EAAE,CAAC,eAAe,EAAE,eAAe,EAAE,aAAa,EAAE,cAAc,EAAE,cAAc,CAAC;QAC/F,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;EAqBd,4CAAsB;;;;EAItB,4CAAsB;;EAEtB,yCAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA0EE;KACrB,CAAC;AACH,CAAC"}

package/dist/modules/agents/builder/skills/target-tasks.skill.js

@@ -6,10 +6,16 @@ function targetTasksSkill() {
     return {
         id: 'agent-builder-target-tasks',
         name: 'Agent Builder Target Tasks',
-        description: 'Use when the user wants the target agent to run something on a recurring schedule (a "task"): a daily/weekly/hourly objective the agent carries out on its own with create_task. Not for one-off requests, chat/event triggers, or config/tool/skill/model edits.',
-        recommendedTools: ['create_task', 'ask_questions', 'read_config', 'patch_config'],
+        description: 'Use when the user wants the target agent to run something on a recurring schedule (a "task"): a daily/weekly/hourly objective the agent carries out on its own with create_tasks. Not for one-off requests, chat/event triggers, or config/tool/skill/model edits.',
+        recommendedTools: [
+            'create_tasks',
+            'ask_questions',
+            'read_config',
+            'patch_config',
+            'publish_agent',
+        ],
         allowedTools: [
-            'create_task',
+            'create_tasks',
             'ask_questions',
             'read_config',
             'patch_config',
@@ -18,14 +24,16 @@ function targetTasksSkill() {
             'search_nodes',
             'get_node_types',
             'ask_credential',
+            'publish_agent',
         ],
         instructions: `\
 ## Purpose
 
-Use this to create a recurring scheduled task for the target agent with
-\`create_task\`. A task = a name + an objective (what the agent does each run) + a
-cron schedule, stored as a \`{ type: "task", id, enabled }\` ref in the agent
-config (\`config.tasks\`) plus a saved body. The config is the source of truth.
+Use this to create one or more recurring scheduled tasks for the target agent
+with \`create_tasks\`. A task = a name + an objective (what the agent does each
+run) + a cron schedule, stored as a \`{ type: "task", id, enabled }\` ref in the
+agent config (\`config.tasks\`) plus a saved body. The config is the source of
+truth.
 
 ## Use when
 
@@ -46,7 +54,7 @@ ${task_objective_template_1.TASK_OBJECTIVE_TEMPLATE}
 
 ## Ask first (required)
 
-Do NOT call \`create_task\` until BOTH of these are true:
+Do NOT call \`create_tasks\` for a task until BOTH of these are true for it:
 
 1. You can fill EVERY section of the objective template above with concrete,
    specific content — no placeholders, no guesses, nothing left to "refine
@@ -57,38 +65,46 @@ Do NOT call \`create_task\` until BOTH of these are true:
 If any section would be empty or a guess, ask the user clarifying questions (use
 \`ask_questions\`, batching multiple questions into one call — discrete options for
 choices, or \`type: "text"\` for open-ended) until you can complete the whole
-template and pin down the cadence. Never create a placeholder or "refine-it-later" task.
+template and pin down the cadence for every task. Never create a placeholder or
+"refine-it-later" task.
 
 ## Workflow
 
-- Gather everything the template needs (every objective section + the cadence),
-  asking clarifying questions until no section is a guess.
-- Write the objective using the exact template above, filling each section.
+- Gather everything the template needs (every objective section + the cadence)
+  for every task, asking clarifying questions until no section is a guess.
+- Write each objective using the exact template above, filling each section.
 - Make sure the agent already has every tool the steps need (an integration,
   node/workflow tool, or web search). If something is missing, add it to the agent
   config first — a task can only use tools the agent already has.
-- Translate the cadence into a valid 5-field cron expression (e.g. daily 09:00
+- Translate each cadence into a valid 5-field cron expression (e.g. daily 09:00
   -> "0 9 * * *"; weekdays 08:30 -> "30 8 * * 1-5"; hourly -> "0 * * * *").
-- Call \`create_task\` with \`name\`, \`objective\`, and \`cronExpression\`.
+- Call \`create_tasks\` once with a \`tasks\` array containing every task you
+  currently know how to write — do not spread multiple fully-specified tasks
+  across separate calls. A single task is still a one-item array.
 - On \`{ ok: false, errors }\` (for example an invalid cron), fix the input and
-  retry.
+  retry the whole batch — an invalid task rejects every task in the call.
 
 ## Rules
 
-- The objective must be self-contained and unambiguous.
-- Use a short, descriptive task name.
-- One task = one objective + one schedule. Create multiple tasks for multiple
-  recurring jobs.
+- Every objective must be self-contained and unambiguous.
+- Use a short, descriptive name per task.
+- One task = one objective + one schedule. Include multiple tasks in the same
+  \`create_tasks\` call for multiple recurring jobs.
 
 ## Gotchas
 
-- \`create_task\` adds a \`{ type: "task", id, enabled }\` ref to \`config.tasks\` and
-  creates the task body. The task is enabled by default and only starts running
-  once the agent is (re)published; tell the user this when relevant.
+- \`create_tasks\` adds a \`{ type: "task", id, enabled }\` ref per task to
+  \`config.tasks\` and creates each task body. Tasks are enabled by default and
+  only start running once the agent is (re)published via \`publish_agent\`; tell
+  the user this when relevant, and call \`publish_agent\` when they ask to publish
+  or make the agent live.
 - To disable or remove a task, edit \`config.tasks\` with \`patch_config\` (set
-  \`enabled: false\`, or drop the ref). Changes take effect on the next publish.
-- \`create_task\` does NOT add tools — if the task needs a tool the agent lacks,
-  add it to the config yourself first.`,
+  \`enabled: false\`, or drop the ref). Changes take effect on the next
+  \`publish_agent\`.
+- \`create_tasks\` does NOT add tools — if a task needs a tool the agent lacks,
+  add it to the config yourself first.
+- Do not call \`create_tasks\` once per task when several are ready; batch them
+  into one call so the whole set is stored in a single round trip.`,
     };
 }
 //# sourceMappingURL=target-tasks.skill.js.map

package/dist/modules/agents/builder/skills/target-tasks.skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"target-tasks.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/target-tasks.skill.ts"],"names":[],"mappings":";;AAIA,4CAyFC;AA3FD,wEAAiG;AAEjG,SAAgB,gBAAgB;IAC/B,OAAO;QACN,EAAE,EAAE,4BAA4B;QAChC,IAAI,EAAE,4BAA4B;QAClC,WAAW,EACV,mQAAmQ;QACpQ,gBAAgB,EAAE,CAAC,aAAa,EAAE,eAAe,EAAE,aAAa,EAAE,cAAc,CAAC;QACjF,YAAY,EAAE;YACb,aAAa;YACb,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;YACd,gBAAgB;YAChB,cAAc;YACd,gBAAgB;YAChB,gBAAgB;SAChB;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;EAqBd,oDAA0B;;EAE1B,iDAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCA8Cc;KACrC,CAAC;AACH,CAAC"}
+{"version":3,"file":"target-tasks.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/target-tasks.skill.ts"],"names":[],"mappings":";;;AAEA,wEAAiG;AAEjG;IACC,OAAO;QACN,EAAE,EAAE,4BAA4B;QAChC,IAAI,EAAE,4BAA4B;QAClC,WAAW,EACV,oQAAoQ;QACrQ,gBAAgB,EAAE;YACjB,cAAc;YACd,eAAe;YACf,aAAa;YACb,cAAc;YACd,eAAe;SACf;QACD,YAAY,EAAE;YACb,cAAc;YACd,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;YACd,gBAAgB;YAChB,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,eAAe;SACf;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;EAsBd,oDAA0B;;EAE1B,iDAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEAsD0C;KACjE,CAAC;AACH,CAAC"}

package/dist/modules/agents/builder/task-objective-template.js.map

@@ -1 +1 @@
-{"version":3,"file":"task-objective-template.js","sourceRoot":"","sources":["../../../../src/modules/agents/builder/task-objective-template.ts"],"names":[],"mappings":";;;AAca,QAAA,uBAAuB,GAAG;;;;;;;;;;;;;;;;;oDAiBa,CAAC;AAGxC,QAAA,0BAA0B,GACtC,6FAA6F;IAC7F,4FAA4F;IAC5F,+FAA+F;IAC/F,qBAAqB,CAAC;AAGV,QAAA,uBAAuB,GAAG,GAAG,kCAA0B,OAAO,+BAAuB,EAAE,CAAC"}
+{"version":3,"file":"task-objective-template.js","sourceRoot":"","sources":["../../../../src/modules/agents/builder/task-objective-template.ts"],"names":[],"mappings":";;;AAca,QAAA,uBAAuB,GAAG;;;;;;;;;;;;;;;;;oDAiBa,CAAC;AAGxC,QAAA,0BAA0B,GACtC,6FAA6F;IAC7F,4FAA4F;IAC5F,+FAA+F;IAC/F,qBAAqB,CAAC;AAGV,QAAA,uBAAuB,GAAG,GAAG,QAAA,0BAA0B,OAAO,QAAA,uBAAuB,EAAE,CAAC"}