n8n 2.41.2 → 2.42.0

package/dist/modules/agents/builder/prompts/tools.prompt.js

@@ -11,8 +11,8 @@ workflows, nodes, custom code tools, or provider tools.
 
 ### Workflow
 
-Use this guidance before calling \`resolve_integration\`, \`search_nodes\`,
-\`search_mcp_servers\`, \`get_node_types\`, \`build_custom_tool\`, or adding,
+Use this guidance before calling \`agent-context\`, \`search_nodes\`,
+\`get_node_types\`, \`build_custom_tool\`, or adding,
 changing, or removing entries in \`tools[]\` / \`mcpServers\` / \`providerTools\`.
 
 For an external product, load \`agent-builder-external-services\` once and
@@ -20,9 +20,9 @@ follow it. It covers the chat-integration-versus-callable-tool decision, chat
 integration setup, and MCP servers. Load \`agent-builder-node-tools\` before
 configuring a node tool.
 
-- Chat/trigger integration: call \`list_integration_types\`, then
-  \`configure_channel\` with a returned type. Do not call \`resolve_integration\`
-  for chat/trigger integrations.
+- Chat/trigger integration: call \`agent-context({ type: "integrations" })\`, then
+  \`configure_channel\` with a returned type. Do not use the queried
+  integration lookup for chat/trigger integrations.
 - A configured chat integration generates its own context and action tools for
   every top-level Agent run, including scheduled tasks. When its capabilities
   include the requested action, do not add a same-platform node, MCP, or
@@ -30,7 +30,7 @@ configuring a node tool.
   is not, by itself, a reason to add another tool.
 - Callable external service: the conversation or trigger happens elsewhere and
   the agent only operates on the product. For each requested non-chat callable
-  service, call \`resolve_integration\` separately, using \`queries\` as
+  service, call \`agent-context\` with \`type: "integrations"\` separately, using \`queries\` as
   alternative search terms for that one service. Do not infer MCP availability
   from memory.
   - \`kind: "mcp"\`: follow the skill's MCP Servers section — credential,
@@ -40,13 +40,12 @@ configuring a node tool.
 
 Use \`search_nodes\` directly only when the user explicitly asks for an n8n node,
 when refining node results, or when a verified MCP server lacks the requested
-capability. Use \`search_mcp_servers\` directly only when refining MCP results or
-when the user explicitly asks to browse the MCP registry.
+capability. Refine MCP results with another \`agent-context\` integration query.
 
 Preference order for non-chat callable services:
-1. MCP servers selected by \`resolve_integration\`
-2. Node tools returned by \`resolve_integration\`
-3. Workflow tools (\`list_workflows\`)
+1. MCP servers returned in the \`agent-context\` integration result
+2. Node tools returned in the \`agent-context\` integration result
+3. Workflow tools (\`agent-context({ type: "attachable-workflows" })\`)
 4. Custom tools (\`build_custom_tool\`) — last resort
 
 Custom tools are for pure computation, validation, formatting, or planning logic;
@@ -54,7 +53,7 @@ they cannot perform live network, filesystem, process, timer, or host I/O.
 
 #### Workflow Tools
 
-- Call \`list_workflows\`; reference supported workflows with \`{ "type": "workflow", "workflowId": "<id>", "workflow": "<name>" }\` using both values it returns.
+- Call \`agent-context({ type: "attachable-workflows" })\`; reference supported workflows with \`{ "type": "workflow", "workflowId": "<id>", "workflow": "<name>" }\` using both values it returns.
 
 #### Node Tools
 
@@ -93,10 +92,10 @@ Custom tools are last resort and only for pure computation. Load
 
 ### Verify
 
-- Chat/trigger integrations bypassed \`resolve_integration\` and were set up
-  through \`configure_channel\`.
+- Chat/trigger integrations used the unqueried \`agent-context\` channel list
+  and were set up through \`configure_channel\`.
 - Each non-chat callable service was resolved separately through
-  \`resolve_integration\` unless the user explicitly requested an n8n node or
+  \`agent-context\` integration search unless the user explicitly requested an n8n node or
   custom MCP server.
 - Workflow tools reference discovered workflow IDs and names.
 - Provider tool keys match the configured model provider and the valid key list.`;

package/dist/modules/agents/builder/prompts/tools.prompt.js.map

@@ -1 +1 @@
-{"version":3,"file":"tools.prompt.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/prompts/tools.prompt.ts"],"names":[],"mappings":";;;AAAa,QAAA,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iFAkGqD,CAAC"}
+{"version":3,"file":"tools.prompt.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/prompts/tools.prompt.ts"],"names":[],"mappings":";;;AAAa,QAAA,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iFAiGqD,CAAC"}

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

@@ -6,11 +6,11 @@ function customToolsSkill() {
         id: 'agent-builder-custom-tools',
         name: 'Agent Builder Custom Tools',
         description: 'Use when building, updating, or registering a pure computation, validation, formatting, or planning tool with build_custom_tool. Not for HTTP, API, crawling, filesystem, or other live integrations — use node or workflow tools for those.',
-        recommendedTools: ['build_custom_tool', 'read_config', 'patch_config'],
+        recommendedTools: ['build_custom_tool', 'agent-context', 'patch_config'],
         allowedTools: [
             'build_custom_tool',
             'ask_questions',
-            'read_config',
+            'agent-context',
             'patch_config',
             'write_config',
         ],

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

@@ -1 +1 @@
-{"version":3,"file":"custom-tools.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/custom-tools.skill.ts"],"names":[],"mappings":";;;AAEA;IACC,OAAO;QACN,EAAE,EAAE,4BAA4B;QAChC,IAAI,EAAE,4BAA4B;QAClC,WAAW,EACV,8OAA8O;QAC/O,gBAAgB,EAAE,CAAC,mBAAmB,EAAE,aAAa,EAAE,cAAc,CAAC;QACtE,YAAY,EAAE;YACb,mBAAmB;YACnB,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;SACd;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2HAyC2G;KACzH,CAAC;AACH,CAAC"}
+{"version":3,"file":"custom-tools.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/custom-tools.skill.ts"],"names":[],"mappings":";;;AAEA;IACC,OAAO;QACN,EAAE,EAAE,4BAA4B;QAChC,IAAI,EAAE,4BAA4B;QAClC,WAAW,EACV,8OAA8O;QAC/O,gBAAgB,EAAE,CAAC,mBAAmB,EAAE,eAAe,EAAE,cAAc,CAAC;QACxE,YAAY,EAAE;YACb,mBAAmB;YACnB,eAAe;YACf,eAAe;YACf,cAAc;YACd,cAAc;SACd;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2HAyC2G;KACzH,CAAC;AACH,CAAC"}

package/dist/modules/agents/builder/skills/external-services.skill.js

@@ -12,23 +12,18 @@ function externalServicesSkill() {
         name: 'Agent Builder External Services',
         description: 'Use when connecting the target agent to an external product: deciding whether Slack, Discord, Linear, Telegram, or another platform is a chat integration/trigger versus a callable service, and adding, removing, or updating chat integrations or MCP servers.',
         recommendedTools: [
-            'resolve_integration',
-            'list_integration_types',
+            'agent-context',
             'configure_channel',
             'ask_credential',
             'verify_mcp_server',
-            'read_config',
             'patch_config',
         ],
         allowedTools: [
-            'resolve_integration',
-            'list_integration_types',
+            'agent-context',
             'configure_channel',
-            'search_mcp_servers',
             'ask_credential',
             'verify_mcp_server',
             'ask_questions',
-            'read_config',
             'patch_config',
             'write_config',
             'report_required_artifact',
@@ -91,7 +86,7 @@ Examples:
   workflow and only needs to search/create/update Linear tickets via MCP or node
   tools.
 
-If \`list_integration_types\` does not return the requested conversation
+If \`agent-context({ type: "integrations" })\` does not return the requested conversation
 platform, do not substitute a platform messaging node as an Agent tool. The
 Agent needs an external channel-bridge workflow instead:
 
@@ -107,8 +102,9 @@ Agent needs an external channel-bridge workflow instead:
 4. If the reporting tool is unavailable, state the same workflow requirement
    clearly in the final reply so the calling surface can create it.
 
-For callable (non-chat) services, call \`resolve_integration\` separately per
-service and follow the returned \`kind\`: \`"mcp"\` -> MCP Servers section
+For callable (non-chat) services, call \`agent-context\` with
+\`type: "integrations"\` and \`queries\` separately per service. Read \`kind\`
+from its \`context\` data: \`"mcp"\` -> MCP Servers section
 below, \`"node"\` -> load \`agent-builder-node-tools\`.
 
 ### Correcting a redundant channel tool
@@ -125,7 +121,7 @@ actions such as \`send_dm\` are available without inbound message context.
 The \`integrations\` array controls how the target agent is triggered.
 
 - These are configured external chat platforms, not built-in Preview chat.
-- Call \`list_integration_types\` first.
+- Call \`agent-context({ type: "integrations" })\` first.
 - Read the returned \`capabilities\`, \`useIntegrationWhen\`, and
   \`useNodeToolWhen\` fields before deciding to add an integration.
 - Pick one returned \`type\` and pass it to \`configure_channel\` as
@@ -135,7 +131,7 @@ The \`integrations\` array controls how the target agent is triggered.
   agent; do not follow up with \`patch_config\`/\`write_config\` to write the
   credential.
 - ${initial_build_prompt_1.INITIAL_BUILD_NOTE} Instead of \`configure_channel\`: after
-  \`list_integration_types\` returns the matching type, \`read_config()\` then
+  \`agent-context({ type: "integrations" })\` returns the matching type, \`agent-context({ type: "config" })\` then
   \`patch_config\` adding \`{ "type": "<integrationType>", "credentialId": "" }\`
   to \`/integrations/-\` (include a minimal valid draft \`settings\` object for
   telegram) so the channel appears in the agent panel as needing setup. Pass
@@ -145,7 +141,7 @@ The \`integrations\` array controls how the target agent is triggered.
   skipped, list it in the closing setup checklist pointing at the channel
   chip in the agent panel.
 - Preserve existing chat integrations unless the user asked to remove them.
-- To remove an existing chat integration, call \`read_config\` and inspect
+- To remove an existing chat integration, call \`agent-context({ type: "config" })\` and inspect
   \`config.integrations\`.
 - If exactly one existing integration matches the requested platform, remove
   that entry with \`patch_config\` by index (or replace \`/integrations\` with a
@@ -157,7 +153,7 @@ The \`integrations\` array controls how the target agent is triggered.
 
 ### Gotchas
 
-- Chat integration types must come from \`list_integration_types\`. A channel
+- Chat integration types must come from \`agent-context({ type: "integrations" })\`. A channel
   absent from its result is unsupported for agents — never invent a type, never
   draft or configure it, and never substitute a workflow node (e.g. a
   WhatsApp/Twilio node) to fake an unsupported chat channel. Instead, explain
@@ -165,7 +161,7 @@ The \`integrations\` array controls how the target agent is triggered.
   returned with their \`capabilities\`, and ask which to use (or whether the
   user wants a workflow path after the limitation is stated).
 - Do not add a chat integration just because the agent needs CRUD or notifications
-  for that product. Resolve the callable capability through \`resolve_integration\`
+  for that product. Resolve the callable capability through \`agent-context\`
   unless the product itself is the chat/trigger context.
 - For recurring or scheduled runs, create a task (\`create_tasks\`) for the
   cadence. Keep a requested chat integration, and use its generated action
@@ -178,15 +174,15 @@ The \`integrations\` array controls how the target agent is triggered.
 
 MCP servers expose external tool catalogs to the target agent over HTTP. They
 live on the top-level \`mcpServers\` array, and each entry maps 1:1 to a
-connected MCP server. Use this section when \`resolve_integration\` returned
+connected MCP server. Use this section when \`agent-context\` returned
 \`kind: "mcp"\`, the user explicitly asks to add or edit an MCP server, or the
 user provides or asks to configure a custom MCP server.
 
 ### Discovery and setup
 
-For a generic external-service request, \`resolve_integration\` must select the
-integration type before MCP setup. If no resolver result is available yet,
-call \`resolve_integration\` with queries matching the requested service.
+For a generic external-service request, search integrations before MCP setup.
+If no result is available yet, call \`agent-context\` with
+\`type: "integrations"\` and queries matching the requested service.
 Resolve one requested service per call; use \`queries\` only for alternative
 search terms for that service.
 
@@ -197,8 +193,8 @@ search terms for that service.
   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:
+- For MCP matches, the \`context\` data contains
+  \`{ kind: "mcp", results: [...] }\`. 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\`.
@@ -223,20 +219,20 @@ Follow these steps for the selected MCP result:
    \`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
+4. Write config: call \`agent-context({ type: "config" })\`, then \`patch_config\` to add the entry to
    \`mcpServers[]\` using the patch pattern below. When the entry already
    exists and verify returned \`credentialApplied: true\`, skip this step — the
    credential is already persisted.
 
 ${initial_build_prompt_1.INITIAL_BUILD_NOTE} For MCP that means: pick the best candidate as an
-assumption (above), then \`read_config()\` and \`patch_config\` a draft
+assumption (above), then \`agent-context({ type: "config" })\` and \`patch_config\` a draft
 \`/mcpServers/-\` entry using \`name\`, \`url\`, \`transport\`,
 \`authentication\`, and \`metadata.nodeTypeName\` from \`selectedResult\` with
 \`credential\` omitted, and skip \`verify_mcp_server\` — there is nothing to
 authenticate yet. Include the credential in the trailing \`finish_setup\` call;
 verify with the returned credential id — on success the tool writes the
 credential into the matching entry itself (\`credentialApplied: true\`); no
-\`read_config\`/\`patch_config\` follow-up for the credential. Existing-agent
+\`agent-context({ type: "config" })\`/\`patch_config\` follow-up for the credential. Existing-agent
 additions keep the immediate ask + verify flow above unchanged.
 
 If verification succeeds but the tools do not cover the requested capability
@@ -280,9 +276,9 @@ credential id from \`ask_credential\`.
 - Success returns \`{ ok: true, tools: [{ name, description }] }\`, and when a
   matching \`mcpServers\` entry exists, also \`credentialApplied: true,
   configMutated: true, agentId\` — the credential is written automatically; do
-  not follow with \`read_config\`/\`patch_config\` for the credential.
+  not follow with \`agent-context({ type: "config" })\`/\`patch_config\` for the credential.
 - When verify succeeds but \`credentialApplied: false\` and the entry already
-  exists, fall back to \`read_config\` then \`patch_config\` for the credential.
+  exists, fall back to \`agent-context({ type: "config" })\` then \`patch_config\` for the credential.
 - For an explicitly requested filter or selected approval list, copy exact names
   from the returned tool list following Tool exposure and approval above.
 - Failure returns \`{ ok: false, error: "..." }\`.
@@ -300,7 +296,7 @@ setup later:
   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
+  connect to), then \`agent-context({ type: "config" })\` and \`patch_config\` the entry, preserving
   every other known field — \`name\`, \`transport\`, \`authentication\`, an
   already-selected credential, and registry \`metadata\`.
 
@@ -342,11 +338,11 @@ Auth, or None) via \`${api_types_1.ASK_QUESTIONS_TOOL_NAME}\`. Then map to:
   initial-build \`finish_setup\` channel card, not \`ask_credential\` or a manual
   config write.
 - The chosen integration matches \`useIntegrationWhen\`; otherwise resolve the
-  callable capability through \`resolve_integration\` and use MCP, node, or
+  callable capability through \`agent-context\` and use MCP, node, or
   workflow tools.
 - No node, MCP, or workflow tool duplicates an action listed by a configured
   chat integration, including for proactive scheduled tasks.
-- Generic non-chat external services were routed through \`resolve_integration\`
+- Generic non-chat external services were routed through \`agent-context\`
   before MCP or node setup.
 - The final \`integrations\` array keeps unrelated integrations intact and
   removes only the requested channel entries.`,

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

@@ -1 +1 @@
-{"version":3,"file":"external-services.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/external-services.skill.ts"],"names":[],"mappings":";;;AACA,+DAAsE;AACtE,8CAAgF;AAEhF,qFAAmF;AACnF,0EAAqE;AAErE,MAAM,mBAAmB,GAAG,IAAA,gDAAuB,EAAC,IAAA,mCAAqB,EAAC,iCAAqB,CAAC,CAAC,CAAC;AAElG;IACC,OAAO;QACN,EAAE,EAAE,iCAAiC;QACrC,IAAI,EAAE,iCAAiC;QACvC,WAAW,EACV,kQAAkQ;QACnQ,gBAAgB,EAAE;YACjB,qBAAqB;YACrB,wBAAwB;YACxB,mBAAmB;YACnB,gBAAgB;YAChB,mBAAmB;YACnB,aAAa;YACb,cAAc;SACd;QACD,YAAY,EAAE;YACb,qBAAqB;YACrB,wBAAwB;YACxB,mBAAmB;YACnB,oBAAoB;YACpB,gBAAgB;YAChB,mBAAmB;YACnB,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;YACd,0BAA0B;YAC1B,YAAY;SACZ;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoGZ,yCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8DhB,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgC3B,yCAAkB;;;;;;;;;;;;;;;;;;EAkBlB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAiEE,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CAsCA;KAC5C,CAAC;AACH,CAAC"}
+{"version":3,"file":"external-services.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/external-services.skill.ts"],"names":[],"mappings":";;;AACA,+DAAsE;AACtE,8CAAgF;AAEhF,qFAAmF;AACnF,0EAAqE;AAErE,MAAM,mBAAmB,GAAG,IAAA,gDAAuB,EAAC,IAAA,mCAAqB,EAAC,iCAAqB,CAAC,CAAC,CAAC;AAElG;IACC,OAAO;QACN,EAAE,EAAE,iCAAiC;QACrC,IAAI,EAAE,iCAAiC;QACvC,WAAW,EACV,kQAAkQ;QACnQ,gBAAgB,EAAE;YACjB,eAAe;YACf,mBAAmB;YACnB,gBAAgB;YAChB,mBAAmB;YACnB,cAAc;SACd;QACD,YAAY,EAAE;YACb,eAAe;YACf,mBAAmB;YACnB,gBAAgB;YAChB,mBAAmB;YACnB,eAAe;YACf,cAAc;YACd,cAAc;YACd,0BAA0B;YAC1B,YAAY;SACZ;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqGZ,yCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8DhB,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgC3B,yCAAkB;;;;;;;;;;;;;;;;;;EAkBlB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAiEE,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CAsCA;KAC5C,CAAC;AACH,CAAC"}

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

@@ -11,7 +11,7 @@ function memorySkill() {
             'ask_embedding_credential',
             'resolve_llm',
             'ask_credential',
-            'read_config',
+            'agent-context',
             'patch_config',
         ],
         allowedTools: [
@@ -19,7 +19,7 @@ function memorySkill() {
             'resolve_llm',
             'ask_credential',
             'ask_questions',
-            'read_config',
+            'agent-context',
             'patch_config',
             'write_config',
         ],

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

@@ -1 +1 @@
-{"version":3,"file":"memory.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/memory.skill.ts"],"names":[],"mappings":";;;AAEA,0EAAqE;AAErE;IACC,OAAO;QACN,EAAE,EAAE,sBAAsB;QAC1B,IAAI,EAAE,sBAAsB;QAC5B,WAAW,EACV,2PAA2P;QAC5P,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;;;;;;;;;;;;;;;;;;;;;;;;;sLAyBsK,yCAAkB;;;;;;;;;;;;;;;;;0EAiB9H;KACxE,CAAC;AACH,CAAC"}
+{"version":3,"file":"memory.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/memory.skill.ts"],"names":[],"mappings":";;;AAEA,0EAAqE;AAErE;IACC,OAAO;QACN,EAAE,EAAE,sBAAsB;QAC1B,IAAI,EAAE,sBAAsB;QAC5B,WAAW,EACV,2PAA2P;QAC5P,gBAAgB,EAAE;YACjB,0BAA0B;YAC1B,aAAa;YACb,gBAAgB;YAChB,eAAe;YACf,cAAc;SACd;QACD,YAAY,EAAE;YACb,0BAA0B;YAC1B,aAAa;YACb,gBAAgB;YAChB,eAAe;YACf,eAAe;YACf,cAAc;YACd,cAAc;SACd;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;sLAyBsK,yCAAkB;;;;;;;;;;;;;;;;;0EAiB9H;KACxE,CAAC;AACH,CAAC"}

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

@@ -9,21 +9,19 @@ function nodeToolsSkill() {
         name: 'Agent Builder Node Tools',
         description: 'Use whenever adding, removing, or updating an n8n node-backed tool, including search_nodes/get_node_types discovery, nodeParameters, node credential slots, $fromAI usage, n8n expressions, and HTTP Request Tool configuration.',
         recommendedTools: [
-            'resolve_integration',
+            'agent-context',
             'search_nodes',
             'get_node_types',
             'ask_credential',
-            'read_config',
             'patch_config',
         ],
         allowedTools: [
-            'resolve_integration',
+            'agent-context',
             'search_nodes',
             'get_node_types',
             'ask_credential',
             'get_resource_locator_options',
             'ask_questions',
-            'read_config',
             'patch_config',
             'write_config',
             'load_skill',
@@ -38,7 +36,7 @@ Use this to discover, configure, and wire node tools into the target agent's
 
 Generic web search, browsing, research, current-information, and source-finding
 requests must use \`config.webSearch\` according to the system prompt's
-web-search rules. Do not call \`resolve_integration\` or \`search_nodes\` for
+web-search rules. Do not search integrations or nodes for
 these requests.
 
 Never add the retired \`@n8n/n8n-nodes-langchain.toolHttpRequest\`. When the
@@ -59,8 +57,9 @@ conventions. Never add an incomplete tool or use a placeholder URL.
 
 ## Workflow
 
-- For a generic external-service request, call \`resolve_integration\` before
-  node discovery unless a resolver result is already available.
+- For a generic external-service request, call \`agent-context\` with
+  \`type: "integrations"\` and \`queries\` before node discovery unless an
+  integration search result is already available.
 - If it returns \`kind: "mcp"\`, load \`agent-builder-external-services\`,
   follow its MCP Servers section, and stop this node-tool workflow.
 - If it returns \`kind: "node"\`, use its returned node results and call
@@ -80,10 +79,10 @@ conventions. Never add an incomplete tool or use a placeholder URL.
 - 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.
-- Gateway credits cover many services, including some community nodes. Adding a node tool with its credential slot omitted triggers server-side assignment: for a covered service the server attaches the managed \`Gateway credits\` credential (\`{ id: null, name: "Gateway credits", __aiGatewayManaged: true }\`) to each required, eligible slot on write — but only when the project has no credential of that type; an existing credential of the type wins and the slot stays empty for the normal credential flow below. Add the tool with the credential slot omitted, then \`read_config\`.
-- Exception — when the user explicitly asks to run a tool on Gateway credits, write \`{ "id": null, "name": "Gateway credits", "__aiGatewayManaged": true }\` into that credential slot yourself: the server keeps it when the service is covered (even if the user has their own credential of the type) and removes it when not covered — check \`read_config\` after the write and resolve a real credential if it was removed.
-- The \`Gateway credits\` managed credential IS the real, working credential — the tool executes through n8n's gateway on Gateway credits, so NO separate API key is needed. It is NOT a placeholder and NOT "invalid for the service", even for a community node. For a slot \`read_config\` shows populated with it: the slot is fully connected and the tool WILL run. Do NOT call \`ask_credential\` for it; do NOT include it in \`finish_setup\`; NEVER clear, remove, or replace it via \`patch_config\`; and NEVER seek a "real" API key to swap in for it. Report the tool as ready, running on Gateway credits — exactly like a managed model. Never tell the user the credential is "not connected"/"not set up" or that the tool "won't run until a credential is added".
-- Only for a required slot that \`read_config\` shows still empty after the write (a service Gateway credits do not cover) do you resolve a real credential: call \`ask_credential\` once before the config mutation for an addition to an existing agent. ${initial_build_prompt_1.INITIAL_BUILD_NOTE} After the trailing \`finish_setup\` resolves the credential, copy the returned credentials into \`node.credentials\` via \`patch_config\`; for resource-locator resolution follow \`agent-builder-resource-locators\` then. 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.
+- Gateway credits cover many services, including some community nodes. Adding a node tool with its credential slot omitted triggers server-side assignment: for a covered service the server attaches the managed \`Gateway credits\` credential (\`{ id: null, name: "Gateway credits", __aiGatewayManaged: true }\`) to each required, eligible slot on write — but only when the project has no credential of that type; an existing credential of the type wins and the slot stays empty for the normal credential flow below. Add the tool with the credential slot omitted, then \`agent-context({ type: "config" })\`.
+- Exception — when the user explicitly asks to run a tool on Gateway credits, write \`{ "id": null, "name": "Gateway credits", "__aiGatewayManaged": true }\` into that credential slot yourself: the server keeps it when the service is covered (even if the user has their own credential of the type) and removes it when not covered — check \`agent-context({ type: "config" })\` after the write and resolve a real credential if it was removed.
+- The \`Gateway credits\` managed credential IS the real, working credential — the tool executes through n8n's gateway on Gateway credits, so NO separate API key is needed. It is NOT a placeholder and NOT "invalid for the service", even for a community node. For a slot \`agent-context({ type: "config" })\` shows populated with it: the slot is fully connected and the tool WILL run. Do NOT call \`ask_credential\` for it; do NOT include it in \`finish_setup\`; NEVER clear, remove, or replace it via \`patch_config\`; and NEVER seek a "real" API key to swap in for it. Report the tool as ready, running on Gateway credits — exactly like a managed model. Never tell the user the credential is "not connected"/"not set up" or that the tool "won't run until a credential is added".
+- Only for a required slot that \`agent-context({ type: "config" })\` shows still empty after the write (a service Gateway credits do not cover) do you resolve a real credential: call \`ask_credential\` once before the config mutation for an addition to an existing agent. ${initial_build_prompt_1.INITIAL_BUILD_NOTE} After the trailing \`finish_setup\` resolves the credential, copy the returned credentials into \`node.credentials\` via \`patch_config\`; for resource-locator resolution follow \`agent-builder-resource-locators\` then. 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.
 - When the agent already has a chat channel configured and the tool needs the same
   credential type, \`ask_credential\` reuses the channel's credential automatically —
   do not ask the user to pick a different one.
@@ -123,7 +122,7 @@ through \`$json\`; use \`$fromAI\` for those fields instead.
 
 ## Verify
 
-- Generic external-service requests were routed through \`resolve_integration\`
+- Generic external-service requests were routed through \`agent-context\`
   before node setup.
 - Node tools use discovered tool node ids and valid node parameters.
 - HTTP Request Tools use a fixed URL supplied by the user.`,

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

@@ -1 +1 @@
-{"version":3,"file":"node-tools.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/node-tools.skill.ts"],"names":[],"mappings":";;;AACA,8CAAyD;AAEzD,0EAAqE;AAErE;IACC,OAAO;QACN,EAAE,EAAE,0BAA0B;QAC9B,IAAI,EAAE,0BAA0B;QAChC,WAAW,EACV,kOAAkO;QACnO,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;;;;;;;;;;;;;;;;;;;;;;;;gBAwBA,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6PA+BsN,yCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DA2CpN;KACzD,CAAC;AACH,CAAC"}
+{"version":3,"file":"node-tools.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/node-tools.skill.ts"],"names":[],"mappings":";;;AACA,8CAAyD;AAEzD,0EAAqE;AAErE;IACC,OAAO;QACN,EAAE,EAAE,0BAA0B;QAC9B,IAAI,EAAE,0BAA0B;QAChC,WAAW,EACV,kOAAkO;QACnO,gBAAgB,EAAE;YACjB,eAAe;YACf,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,cAAc;SACd;QACD,YAAY,EAAE;YACb,eAAe;YACf,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,8BAA8B;YAC9B,eAAe;YACf,cAAc;YACd,cAAc;YACd,YAAY;SACZ;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;gBAwBA,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mRAgC4O,yCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DA2C1O;KACzD,CAAC;AACH,CAAC"}

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

@@ -12,7 +12,7 @@ function resourceLocatorsSkill() {
             'get_node_types',
             'ask_credential',
             'get_resource_locator_options',
-            'read_config',
+            'agent-context',
             'patch_config',
         ],
         allowedTools: [
@@ -21,7 +21,7 @@ function resourceLocatorsSkill() {
             'ask_credential',
             'get_resource_locator_options',
             'ask_questions',
-            'read_config',
+            'agent-context',
             'patch_config',
             'write_config',
         ],

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,0EAAqE;AAErE;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;;;;;;;;;;;;;;;;;;;EAmBd,yCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAyFgC;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,0EAAqE;AAErE;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,eAAe;YACf,cAAc;SACd;QACD,YAAY,EAAE;YACb,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,8BAA8B;YAC9B,eAAe;YACf,eAAe;YACf,cAAc;YACd,cAAc;SACd;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;EAmBd,yCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAyFgC;KAClD,CAAC;AACH,CAAC"}

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

@@ -7,14 +7,8 @@ function subAgentsSkill() {
         id: 'agent-builder-sub-agents',
         name: 'Agent Builder Sub-Agents',
         description: 'Use when configuring inline or saved sub-agent delegation for the target agent, selecting same-project sub-agents, or changing subAgents.maxChildren.',
-        recommendedTools: ['list_sub_agents', 'ask_questions', 'read_config', 'patch_config'],
-        allowedTools: [
-            'list_sub_agents',
-            'ask_questions',
-            'read_config',
-            'patch_config',
-            'write_config',
-        ],
+        recommendedTools: ['agent-context', 'ask_questions', 'patch_config'],
+        allowedTools: ['agent-context', 'ask_questions', 'patch_config', 'write_config'],
         instructions: `\
 ## Purpose
 
@@ -47,13 +41,15 @@ target agent may select by id when they are a better fit than an inline subagent
 
 ## Saved sub-agent workflow
 
-1. Call \`list_sub_agents\` to discover same-project agents that can be added.
-   Do not write agent ids from memory, prose, or user-entered free text.
-2. If agents are available and the user has not named exact agents,
+1. Call \`agent-context({ type: "config" })\` to get the target agent's id.
+   Then call \`agent-context({ type: "agents" })\` to discover same-project agents.
+   Exclude the target id from the result. Do not write agent ids
+   from memory, prose, or user-entered free text.
+2. If other agents are available and the user has not named exact agents,
    call \`ask_questions\` with one \`type: "multi"\` question whose \`options\`
    are the returned agent names. Map each selected option back to the
-   matching \`agentId\` from the \`list_sub_agents\` result.
-3. If no agents are available, do not configure saved subagents. Inline
+   matching \`agentId\` from the \`agent-context({ type: "agents" })\` result.
+3. If no other agents are available, do not configure saved subagents. Inline
    delegation still works without saved-agent refs.
 4. Determine the parent-owned routing guidance for each selected saved
    subagent. Store it as \`useWhen\`, for example
@@ -61,26 +57,26 @@ target agent may select by id when they are a better fit than an inline subagent
 5. If it is unclear when a selected saved subagent should be used, ask the user
    a follow-up before patching \`subAgents.agents\`. Do not invent vague routing
    guidance.
-6. Call \`read_config\`.
+6. Call \`agent-context({ type: "config" })\`.
 7. Patch selected saved agents into \`subAgents.agents\`. Avoid duplicates.
 
 Example patch flow:
 
-1. \`list_sub_agents()\`.
-2. If it returns one or more agents and the user has not named exact ones, call
+1. \`agent-context({ type: "config" })\`, then \`agent-context({ type: "agents" })\`.
+2. If it returns one or more other agents and the user has not named exact ones, call
    \`ask_questions({ questions: [{ type: "multi", ... }] })\` with those agents
    as options.
 3. If the user's request does not make the routing rule clear, ask when each
    selected saved subagent should be used.
-4. \`read_config()\`.
+4. \`agent-context({ type: "config" })\`.
 5. \`patch_config(...)\` adding selected
    \`{ "agentId": "<returned-agent-id>", "useWhen": "Use for ..." }\` refs to
    \`/subAgents/agents\`.
 
 ## Rules
 
-- Saved subagents run their current draft in Preview/test runs and their
-  published version in production runs. Delegating to a never-published agent
+- Saved subagents use their current draft in Preview and test sessions, and their
+  published version in production sessions. Delegating to a never-published agent
   fails in production, so tell the user to publish saved subagents the target
   agent relies on before production use.
 - If the resumed values include text that is not one of the listed agent ids,

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":";;;AACA,8CAIwB;AAExB;IACC,OAAO;QACN,EAAE,EAAE,0BAA0B;QAC9B,IAAI,EAAE,0BAA0B;QAChC,WAAW,EACV,uJAAuJ;QACxJ,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;;;;;;;;;;;;;;;;;;;;;;sDAsBsC,sCAA0B,OAAO,sCAA0B,gCAAgC,0CAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAyF1H,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,uJAAuJ;QACxJ,gBAAgB,EAAE,CAAC,eAAe,EAAE,eAAe,EAAE,cAAc,CAAC;QACpE,YAAY,EAAE,CAAC,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,cAAc,CAAC;QAChF,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;sDAsBsC,sCAA0B,OAAO,sCAA0B,gCAAgC,0CAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDA2F1H,sCAA0B,OAAO,sCAA0B,GAAG;KACjH,CAAC;AACH,CAAC"}

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

@@ -8,21 +8,17 @@ function targetSkillsSkill() {
         name: 'Agent Builder Target Skills',
         description: 'Use when designing, creating, or editing target-agent behavior that belongs in focused load-on-demand skills, including when the user describes a function without calling it a skill; not for builder guidance or universal target-agent instructions.',
         recommendedTools: [
-            'list_skills',
-            'read_skill',
+            'agent-context',
             'update_skill',
             'create_skills',
             'ask_questions',
-            'read_config',
             'patch_config',
         ],
         allowedTools: [
-            'list_skills',
-            'read_skill',
+            'agent-context',
             'update_skill',
             'create_skills',
             'ask_questions',
-            'read_config',
             'patch_config',
             'write_config',
         ],
@@ -76,17 +72,17 @@ skill.
 - Classify requested behavior before writing: identity, overall purpose, and
   universal rules stay in main instructions; each distinct or conditional
   function becomes a focused skill.
-- Call \`read_config\` and use its \`skills\` refs as the authoritative set of
+- Call \`agent-context({ type: "config" })\` and use its \`skills\` refs as the authoritative set of
   skills attached to the target agent.
-- Call \`list_skills\` once and compare its metadata with the attached ids from
+- Call \`agent-context({ type: "skills" })\` once and compare its metadata with the attached ids from
   the config. Use each description as the routing contract to identify whether
   an attached skill already owns the capability. Do not read every skill body.
-- Call \`read_skill\` only for the relevant attached skill. Its default response
+- Call \`agent-context({ type: "skill", skillId: "<id>" })\` only for the relevant attached skill. Its default response
   includes reference paths and sizes but omits reference content; request
   specific \`referencePaths\` only when that content is needed.
 - Call \`update_skill\` for an existing capability, changing only the supplied
   fields and preserving its id and existing config reference. Pass the
-  \`skillHash\` from the \`read_skill\` result you based the change on as
+  \`skillHash\` from the \`agent-context({ type: "skill", skillId: "<id>" })\` result you based the change on as
   \`baseSkillHash\`; on a stale skill error, read the skill again and retry once.
   Do not create a replacement skill. Pass \`null\` for \`allowedTools\` to remove the tool
   restriction or for \`references\` to remove all references; do not pass empty
@@ -105,7 +101,7 @@ skill.
 - \`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 new skill, call \`read_config\` again for a fresh
+- After it returns an id per new skill, call \`agent-context({ type: "config" })\` again for a fresh
   config and hash.
 - Use \`patch_config\` or \`write_config\` to add a \`{ "type": "skill", "id": "<returned id>" }\`
   entry per skill to \`skills\`.

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":";;;AAEA,gEAIgC;AAEhC;IACC,OAAO;QACN,EAAE,EAAE,6BAA6B;QACjC,IAAI,EAAE,6BAA6B;QACnC,WAAW,EACV,yPAAyP;QAC1P,gBAAgB,EAAE;YACjB,aAAa;YACb,YAAY;YACZ,cAAc;YACd,eAAe;YACf,eAAe;YACf,aAAa;YACb,cAAc;SACd;QACD,YAAY,EAAE;YACb,aAAa;YACb,YAAY;YACZ,cAAc;YACd,eAAe;YACf,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;SACd;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;EAyBd,4CAAsB;;;;EAItB,4CAAsB;;EAEtB,yCAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAmGE;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,yPAAyP;QAC1P,gBAAgB,EAAE;YACjB,eAAe;YACf,cAAc;YACd,eAAe;YACf,eAAe;YACf,cAAc;SACd;QACD,YAAY,EAAE;YACb,eAAe;YACf,cAAc;YACd,eAAe;YACf,eAAe;YACf,cAAc;YACd,cAAc;SACd;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;EAyBd,4CAAsB;;;;EAItB,4CAAsB;;EAEtB,yCAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAmGE;KACrB,CAAC;AACH,CAAC"}

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

@@ -9,22 +9,19 @@ function targetTasksSkill() {
         description: 'Use when the user wants to create or change something the target agent runs on a recurring schedule (a "task"). Not for one-off requests, chat/event triggers, or config/tool/skill/model edits.',
         recommendedTools: [
             'create_tasks',
-            'list_tasks',
+            'agent-context',
             'update_task',
             'ask_questions',
-            'read_config',
             'patch_config',
             'publish_agent',
         ],
         allowedTools: [
             'create_tasks',
-            'list_tasks',
+            'agent-context',
             'update_task',
             'ask_questions',
-            'read_config',
             'patch_config',
             'write_config',
-            'list_workflows',
             'search_nodes',
             'get_node_types',
             'ask_credential',
@@ -34,7 +31,7 @@ function targetTasksSkill() {
 ## Purpose
 
 Use this to create recurring scheduled tasks with \`create_tasks\`, discover
-them with \`list_tasks\`, and edit their saved bodies with \`update_task\`.
+them with \`agent-context({ type: "tasks" })\`, and edit their saved bodies with \`update_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 for
@@ -82,7 +79,7 @@ Initial Build rules in your system prompt. Never create a placeholder or
 
 ## Workflow
 
-- For an existing task, call \`list_tasks\` to resolve its current id and body.
+- For an existing task, call \`agent-context({ type: "tasks" })\` to resolve its current id and body.
   Then call \`update_task\` with only the fields the user asked to change. Never
   rewrite the objective for a name-only or schedule-only edit.
 - For each new or replacement objective, fill every template section with

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":";;;AAEA,wEAAiG;AAEjG;IACC,OAAO;QACN,EAAE,EAAE,4BAA4B;QAChC,IAAI,EAAE,4BAA4B;QAClC,WAAW,EACV,kMAAkM;QACnM,gBAAgB,EAAE;YACjB,cAAc;YACd,YAAY;YACZ,aAAa;YACb,eAAe;YACf,aAAa;YACb,cAAc;YACd,eAAe;SACf;QACD,YAAY,EAAE;YACb,cAAc;YACd,YAAY;YACZ,aAAa;YACb,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;YACd,gBAAgB;YAChB,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,eAAe;SACf;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;EAyBd,oDAA0B;;EAE1B,iDAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEAkF0C;KACjE,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,kMAAkM;QACnM,gBAAgB,EAAE;YACjB,cAAc;YACd,eAAe;YACf,aAAa;YACb,eAAe;YACf,cAAc;YACd,eAAe;SACf;QACD,YAAY,EAAE;YACb,cAAc;YACd,eAAe;YACf,aAAa;YACb,eAAe;YACf,cAAc;YACd,cAAc;YACd,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,eAAe;SACf;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;EAyBd,oDAA0B;;EAE1B,iDAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEAkF0C;KACjE,CAAC;AACH,CAAC"}