@hotmeshio/long-tail 0.1.13 → 0.1.14

package/build/system/seed/server-definitions.d.ts

@@ -2931,10 +2931,13 @@ export declare const SEED_MCP_SERVERS: ({
                     type: string;
                     description: string;
                 };
-                data: {
+                field: {
                     type: string;
                     description: string;
                 };
+                data: {
+                    description: string;
+                };
                 tags: {
                     type: string;
                     items: {
@@ -2964,6 +2967,7 @@ export declare const SEED_MCP_SERVERS: ({
                     type: string;
                     description: string;
                 };
+                field?: undefined;
                 data?: undefined;
                 tags?: undefined;
                 query?: undefined;
@@ -3000,6 +3004,7 @@ export declare const SEED_MCP_SERVERS: ({
                     description: string;
                 };
                 key?: undefined;
+                field?: undefined;
                 data?: undefined;
                 offset?: undefined;
                 path?: undefined;
@@ -3033,6 +3038,7 @@ export declare const SEED_MCP_SERVERS: ({
                     description: string;
                 };
                 key?: undefined;
+                field?: undefined;
                 data?: undefined;
                 query?: undefined;
                 path?: undefined;
@@ -3048,6 +3054,7 @@ export declare const SEED_MCP_SERVERS: ({
             properties: {
                 domain?: undefined;
                 key?: undefined;
+                field?: undefined;
                 data?: undefined;
                 tags?: undefined;
                 query?: undefined;
@@ -3079,6 +3086,7 @@ export declare const SEED_MCP_SERVERS: ({
                 value: {
                     description: string;
                 };
+                field?: undefined;
                 data?: undefined;
                 tags?: undefined;
                 query?: undefined;
@@ -3096,4 +3104,107 @@ export declare const SEED_MCP_SERVERS: ({
     tags: string[];
     compile_hints: string;
     credential_providers: never[];
+} | {
+    name: string;
+    description: string;
+    transport_type: string;
+    transport_config: {
+        builtin: boolean;
+        process: string;
+    };
+    tool_manifest: ({
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                endpoint: {
+                    type: string;
+                    description: string;
+                };
+                method: {
+                    type: string;
+                    description: string;
+                };
+                headers: {
+                    type: string;
+                    description: string;
+                };
+                query: {
+                    type: string;
+                    description: string;
+                };
+                body: {
+                    description: string;
+                };
+                request_schema: {
+                    type: string;
+                    description: string;
+                };
+                response_schema: {
+                    type: string;
+                    description: string;
+                };
+                timeout_ms: {
+                    type: string;
+                    description: string;
+                };
+                credential_provider: {
+                    type: string;
+                    description: string;
+                };
+                credential_label: {
+                    type: string;
+                    description: string;
+                };
+                auth_scheme: {
+                    type: string;
+                    description: string;
+                };
+                auth_header: {
+                    type: string;
+                    description: string;
+                };
+                data?: undefined;
+                schema?: undefined;
+            };
+            required: string[];
+        };
+    } | {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                data: {
+                    description: string;
+                };
+                schema: {
+                    type: string;
+                    description: string;
+                };
+                endpoint?: undefined;
+                method?: undefined;
+                headers?: undefined;
+                query?: undefined;
+                body?: undefined;
+                request_schema?: undefined;
+                response_schema?: undefined;
+                timeout_ms?: undefined;
+                credential_provider?: undefined;
+                credential_label?: undefined;
+                auth_scheme?: undefined;
+                auth_header?: undefined;
+            };
+            required: string[];
+        };
+    })[];
+    metadata: {
+        builtin: boolean;
+        category: string;
+        level?: undefined;
+    };
+    tags: string[];
+    compile_hints: string;
+    credential_providers: never[];
 })[];

package/build/system/seed/server-definitions.js

@@ -192,4 +192,41 @@ exports.SEED_MCP_SERVERS = [
             'list_domains returns all domains with counts, useful for discovering what knowledge exists.',
         credential_providers: [],
     },
+    {
+        name: 'long-tail-schema-exchange',
+        description: 'Schema-driven data exchange with external service endpoints. Validates requests and responses ' +
+            'against JSON Schema. Transport is an implementation detail — the principle is endpoint + schema + ' +
+            'validated exchange. Use this as the building block for wrapping any external API.',
+        transport_type: 'stdio',
+        transport_config: { builtin: true, process: 'in-memory' },
+        tool_manifest: tool_manifests_data_1.SCHEMA_EXCHANGE_TOOLS,
+        metadata: { builtin: true, category: 'data' },
+        tags: ['api', 'schema', 'exchange', 'validation', 'fetch'],
+        compile_hints: 'Schema-driven data exchange for external API endpoints. Validates requests before sending and responses after receiving against JSON Schema. ' +
+            'When building a workflow that calls an external API endpoint, use exchange as the worker activity. ' +
+            'Embed request_schema and response_schema as STATIC values in input.maps (not dynamic inputs — schemas are fixed per endpoint). ' +
+            'Build the endpoint URL using @pipe concat for template variables. Use "url" for the endpoint field name. ' +
+            'CRITICAL — Authorization headers: when the trigger provides a token and you need to build "Bearer {token}", use this EXACT YAML structure for the headers field in input.maps:\n' +
+            '  headers:\n' +
+            '    Authorization:\n' +
+            '      \'@pipe\':\n' +
+            '        - [\'Bearer \', \'{trigger_XXXX.output.data.token}\']\n' +
+            '        - [\'{@string.concat}\']\n' +
+            'NEVER nest @pipe inside @pipe for headers. NEVER use @object.fromEntries for headers. The headers field is a plain object — each header name is a key, and its value can be a static string or a single @pipe expression. ' +
+            'The trigger input_schema should reflect the endpoint\'s dynamic parameters (IDs, search terms, pagination) plus base_url and credentials. ' +
+            'CRITICAL — exchange output structure: the exchange tool returns { status, data, headers, elapsed_ms, validated, validation_errors }. ' +
+            'The actual API response body is inside the "data" field. So to reference a response field like "token", ' +
+            'use {activity.output.data.data.token} (NOT {activity.output.data.token}). ' +
+            'The double .data is because HotMesh wraps activity output in .output.data, and the exchange tool puts the API response in its own .data field. ' +
+            'For job.maps on the last activity: job.maps.token: \'{exchange_xxxx.output.data.data.token}\'. ' +
+            'Also surface validated and status: job.maps.validated: \'{exchange_xxxx.output.data.validated}\', job.maps.status: \'{exchange_xxxx.output.data.status}\'. ' +
+            'response_schema enables self-testing: schedule the compiled tool on cron against a dev/staging server — if validation fails, the API schema changed. ' +
+            'request_schema prevents malformed requests from ever leaving the system. ' +
+            'Both schemas are optional — use response_schema alone for read endpoints, both for write endpoints, neither for exploratory calls. ' +
+            'For authentication, prefer credential_provider over manually wiring tokens in headers. ' +
+            'Set credential_provider to the provider name registered in the connection store (e.g. "stripe", "epic", "google"). ' +
+            'The tool resolves the credential from the calling principal\'s stored connections at the last mile — no token input needed, auto-refreshes expired tokens. ' +
+            'Use auth_scheme for non-Bearer schemes (e.g. "Basic", "Token") and auth_header for APIs that use X-API-Key instead of Authorization.',
+        credential_providers: [],
+    },
 ];

package/build/system/seed/tool-manifests-data.d.ts

@@ -284,6 +284,93 @@ export declare const HTTP_FETCH_TOOLS: ({
         required: string[];
     };
 })[];
+export declare const SCHEMA_EXCHANGE_TOOLS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            endpoint: {
+                type: string;
+                description: string;
+            };
+            method: {
+                type: string;
+                description: string;
+            };
+            headers: {
+                type: string;
+                description: string;
+            };
+            query: {
+                type: string;
+                description: string;
+            };
+            body: {
+                description: string;
+            };
+            request_schema: {
+                type: string;
+                description: string;
+            };
+            response_schema: {
+                type: string;
+                description: string;
+            };
+            timeout_ms: {
+                type: string;
+                description: string;
+            };
+            credential_provider: {
+                type: string;
+                description: string;
+            };
+            credential_label: {
+                type: string;
+                description: string;
+            };
+            auth_scheme: {
+                type: string;
+                description: string;
+            };
+            auth_header: {
+                type: string;
+                description: string;
+            };
+            data?: undefined;
+            schema?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            data: {
+                description: string;
+            };
+            schema: {
+                type: string;
+                description: string;
+            };
+            endpoint?: undefined;
+            method?: undefined;
+            headers?: undefined;
+            query?: undefined;
+            body?: undefined;
+            request_schema?: undefined;
+            response_schema?: undefined;
+            timeout_ms?: undefined;
+            credential_provider?: undefined;
+            credential_label?: undefined;
+            auth_scheme?: undefined;
+            auth_header?: undefined;
+        };
+        required: string[];
+    };
+})[];
 export declare const DOCS_TOOLS: ({
     name: string;
     description: string;

package/build/system/seed/tool-manifests-data.js

@@ -1,7 +1,7 @@
 "use strict";
 // ── Data, storage, HTTP, and OAuth tool manifests ───────────────────────────
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OAUTH_TOOLS = exports.DOCS_TOOLS = exports.HTTP_FETCH_TOOLS = exports.FILE_STORAGE_TOOLS = exports.DB_QUERY_TOOLS = exports.VISION_ANALYSIS_TOOLS = exports.TRANSLATION_TOOLS = void 0;
+exports.OAUTH_TOOLS = exports.DOCS_TOOLS = exports.SCHEMA_EXCHANGE_TOOLS = exports.HTTP_FETCH_TOOLS = exports.FILE_STORAGE_TOOLS = exports.DB_QUERY_TOOLS = exports.VISION_ANALYSIS_TOOLS = exports.TRANSLATION_TOOLS = void 0;
 exports.TRANSLATION_TOOLS = [
     {
         name: 'translate_content',
@@ -141,6 +141,42 @@ exports.HTTP_FETCH_TOOLS = [
         },
     },
 ];
+exports.SCHEMA_EXCHANGE_TOOLS = [
+    {
+        name: 'exchange',
+        description: 'Exchange data with an external service endpoint under schema enforcement. Validates request body against request_schema before sending and response body against response_schema after receiving. Transport is hidden — the principle is endpoint + schema + validated exchange.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                endpoint: { type: 'string', description: 'Service endpoint URL' },
+                method: { type: 'string', description: 'HTTP method: GET, POST, PUT, DELETE, PATCH' },
+                headers: { type: 'object', description: 'Request headers' },
+                query: { type: 'object', description: 'Query parameters' },
+                body: { description: 'Request body (validated against request_schema if provided)' },
+                request_schema: { type: 'object', description: 'JSON Schema for request body validation' },
+                response_schema: { type: 'object', description: 'JSON Schema for response body validation' },
+                timeout_ms: { type: 'number', description: 'Request timeout in milliseconds' },
+                credential_provider: { type: 'string', description: 'Credential provider name — resolves auth from the connection store automatically' },
+                credential_label: { type: 'string', description: 'Credential label for multi-credential accounts' },
+                auth_scheme: { type: 'string', description: 'Auth scheme (default: Bearer)' },
+                auth_header: { type: 'string', description: 'Header name for credential (default: Authorization)' },
+            },
+            required: ['endpoint', 'method'],
+        },
+    },
+    {
+        name: 'validate_schema',
+        description: 'Validate any value against a JSON Schema without making a network call. Useful for pre-validation, testing, and transform verification.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                data: { description: 'The value to validate' },
+                schema: { type: 'object', description: 'JSON Schema to validate against' },
+            },
+            required: ['data', 'schema'],
+        },
+    },
+];
 exports.DOCS_TOOLS = [
     {
         name: 'list_docs',

package/build/system/seed/tool-manifests-knowledge.d.ts

@@ -12,10 +12,13 @@ export declare const KNOWLEDGE_TOOLS: ({
                 type: string;
                 description: string;
             };
-            data: {
+            field: {
                 type: string;
                 description: string;
             };
+            data: {
+                description: string;
+            };
             tags: {
                 type: string;
                 items: {
@@ -45,6 +48,7 @@ export declare const KNOWLEDGE_TOOLS: ({
                 type: string;
                 description: string;
             };
+            field?: undefined;
             data?: undefined;
             tags?: undefined;
             query?: undefined;
@@ -81,6 +85,7 @@ export declare const KNOWLEDGE_TOOLS: ({
                 description: string;
             };
             key?: undefined;
+            field?: undefined;
             data?: undefined;
             offset?: undefined;
             path?: undefined;
@@ -114,6 +119,7 @@ export declare const KNOWLEDGE_TOOLS: ({
                 description: string;
             };
             key?: undefined;
+            field?: undefined;
             data?: undefined;
             query?: undefined;
             path?: undefined;
@@ -129,6 +135,7 @@ export declare const KNOWLEDGE_TOOLS: ({
         properties: {
             domain?: undefined;
             key?: undefined;
+            field?: undefined;
             data?: undefined;
             tags?: undefined;
             query?: undefined;
@@ -160,6 +167,7 @@ export declare const KNOWLEDGE_TOOLS: ({
             value: {
                 description: string;
             };
+            field?: undefined;
             data?: undefined;
             tags?: undefined;
             query?: undefined;

package/build/system/seed/tool-manifests-knowledge.js

@@ -5,14 +5,15 @@ exports.KNOWLEDGE_TOOLS = void 0;
 exports.KNOWLEDGE_TOOLS = [
     {
         name: 'store_knowledge',
-        description: 'Store or update a knowledge entry. Upserts by domain+key: merges data and unions tags if the entry already exists.',
+        description: 'Store a value in a 3-level additive hierarchy: domain > key > field. Upserts by domain+key — fields accumulate across calls. Same domain+key+field overwrites that field. When field is provided, data can be any type. When omitted, data must be an object.',
         inputSchema: {
             type: 'object',
             properties: {
-                domain: { type: 'string', description: 'Knowledge domain (namespace)' },
-                key: { type: 'string', description: 'Unique key within domain' },
-                data: { type: 'object', description: 'JSONB payload to store' },
-                tags: { type: 'array', items: { type: 'string' }, description: 'Categorization tags' },
+                domain: { type: 'string', description: 'Top level — groups entries by namespace (e.g. "screenshots", "config")' },
+                key: { type: 'string', description: 'Second level — unique identifier within domain (e.g. "homepage")' },
+                field: { type: 'string', description: 'Third level (leaf) — names a specific field. Different fields accumulate; same field overwrites.' },
+                data: { description: 'The value to store. Any type when field is provided; must be an object when field is omitted.' },
+                tags: { type: 'array', items: { type: 'string' }, description: 'Categorization tags (unioned on upsert)' },
             },
             required: ['domain', 'key', 'data'],
         },

package/build/system/workflows/mcp-workflow-builder/prompts.d.ts

@@ -4,5 +4,5 @@
  * The system prompt teaches the LLM how to construct HotMesh YAML DAGs
  * directly from tool schemas — no execution trace needed.
  */
-export declare function BUILDER_SYSTEM_PROMPT(toolInventory: string): string;
+export declare function BUILDER_SYSTEM_PROMPT(toolInventory: string, activitySuffix?: string): string;
 export declare const REFINE_PROMPT = "The workflow was tested and produced errors or incorrect results. Review the execution trace below and fix the YAML.\n\nCommon issues:\n- Missing .png extension on screenshot paths\n- Field name mismatch between output and input (e.g., producer outputs \"path\" but consumer expects \"image\")\n- Missing _scope or workflowName in input.maps\n- Wrong activity ID references in mappings\n- Missing job.maps on the final activity\n\nReturn the same JSON format as before with corrected yaml, activity_manifest, etc.";

package/build/system/workflows/mcp-workflow-builder/prompts.js

@@ -8,7 +8,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.REFINE_PROMPT = void 0;
 exports.BUILDER_SYSTEM_PROMPT = BUILDER_SYSTEM_PROMPT;
-function BUILDER_SYSTEM_PROMPT(toolInventory) {
+function BUILDER_SYSTEM_PROMPT(toolInventory, activitySuffix) {
+    const suffix = activitySuffix || Math.random().toString(36).slice(2, 6);
     return `You are a HotMesh workflow builder. Given a natural language description and a set of available MCP tools, you construct a deterministic YAML DAG workflow.
 
 You do NOT execute tools. You reason about their input/output schemas and build the YAML declaratively.
@@ -45,7 +46,7 @@ app:
 ### trigger
 Entry point. Receives user input. Always the first activity.
 \`\`\`yaml
-trigger_x8kf:
+trigger_${suffix}:
   title: Trigger
   type: trigger
   output:
@@ -56,7 +57,7 @@ trigger_x8kf:
 ### worker
 Executes an MCP tool. Receives data via input.maps, produces output. Same suffix as the trigger.
 \`\`\`yaml
-capture_x8kf:
+capture_${suffix}:
   title: Capture Page
   type: worker
   topic: <same as subscribes>
@@ -64,10 +65,10 @@ capture_x8kf:
     schema:
       type: object
     maps:
-      url: '{trigger_x8kf.output.data.url}'
+      url: '{trigger_${suffix}.output.data.url}'
       screenshot_path:
         '@pipe':
-          - ['{trigger_x8kf.output.data.slug}', '.png']
+          - ['{trigger_${suffix}.output.data.slug}', '.png']
           - ['{@string.concat}']
       workflowName: capture_page
   output:
@@ -150,7 +151,7 @@ Sub-pipes must be ROW-LEVEL entries in the parent pipe array — each is a separ
 dated_key:
   '@pipe':
     - '@pipe':
-      - ['{trigger_x8kf.output.data.slug}', '-']
+      - ['{trigger_${suffix}.output.data.slug}', '-']
       - ['{@string.concat}']
     - '@pipe':
       - ['{@date.now}']
@@ -168,7 +169,7 @@ CRITICAL RULES for nested @pipe:
 path:
   '@pipe':
     - '@pipe':
-      - ['{trigger_x8kf.output.data.domain}', '/', '{trigger_x8kf.output.data.key}', '/']
+      - ['{trigger_${suffix}.output.data.domain}', '/', '{trigger_${suffix}.output.data.key}', '/']
       - ['{@string.concat}']
     - '@pipe':
       - ['{@date.now}']
@@ -203,29 +204,29 @@ IMPORTANT: A bare array like \`['.png']\` as a row after sub-pipes will CRASH
 
 1. **Trigger first**: Every workflow starts with a trigger activity
 2. **Worker per tool**: Each MCP tool call is a worker activity
-3. **Collision-proof activity IDs**: Multiple workflows share the same app namespace. Activity IDs MUST be globally unique within the app. Use a descriptive name with a shared 4-char random suffix appended to every activity in the flow: \`trigger_x8kf\`, \`capture_x8kf\`, \`analyze_x8kf\`, \`store_x8kf\`. The suffix is the same for all activities in one workflow but unique across workflows. NEVER use bare names like \`trigger\`, \`capture\`, \`analyze\` — they WILL collide with other workflows in the same app.
+3. **Collision-proof activity IDs**: Multiple workflows share the same app namespace. Activity IDs MUST be globally unique within the app. Use a descriptive name with a shared 4-char random suffix appended to every activity in the flow: \`trigger_${suffix}\`, \`capture_${suffix}\`, \`analyze_${suffix}\`, \`store_${suffix}\`. The suffix is the same for all activities in one workflow but unique across workflows. NEVER use bare names like \`trigger\`, \`capture\`, \`analyze\` — they WILL collide with other workflows in the same app.
 4. **workflowName**: Every worker MUST have \`workflowName: '<tool_name>'\` in its input.maps — this routes to the correct MCP tool handler
 5. **mcp_server_id**: In the activity_manifest, use the exact hyphenated server name from the inventory (e.g., "long-tail-vision"), NOT the underscored tool prefix (e.g., "long_tail_vision")
-6. **_scope threading**: Every worker MUST have \`_scope: '{trigger_x8kf.output.data._scope}'\` (using YOUR trigger's ID) for IAM context
+6. **_scope threading**: Every worker MUST have \`_scope: '{trigger_${suffix}.output.data._scope}'\` (using YOUR trigger's ID) for IAM context
 7. **Wire outputs forward**: Use \`{prevActivity.output.data.fieldName}\` to pass data between steps
 8. **Use @pipe for transforms**: When a value needs runtime computation (date stamp, string concat, slugify), use @pipe — never hardcode computed values
-9. **Simple fields stay simple**: If a field just passes a trigger value through (domain, key, url), use a plain reference like \`'{trigger_x8kf.output.data.domain}'\` — NEVER wrap it in @pipe. Only use @pipe when actual transformation is needed.
+9. **Simple fields stay simple**: If a field just passes a trigger value through (domain, key, url), use a plain reference like \`'{trigger_${suffix}.output.data.domain}'\` — NEVER wrap it in @pipe. Only use @pipe when actual transformation is needed.
 10. **File extensions**: Screenshot paths MUST include .png extension. Use @pipe concat if deriving from a slug
 11. **job.maps on last activity**: The final activity should have job.maps to promote output fields to the workflow result
 12. **Linear transitions**: Chain activities with transitions unless branching or iteration is needed
 13. **Conditional transitions**: For branching, use multi-target transitions with conditions:
 \`\`\`yaml
 transitions:
-  check_x8kf:
-    - to: handle_error_x8kf
+  check_${suffix}:
+    - to: handle_error_${suffix}
       conditions:
         code: 500
-    - to: proceed_x8kf
+    - to: proceed_${suffix}
 \`\`\`
 Conditions can match on \`code\` (HTTP status) or \`match\` (field comparisons). The first matching condition wins; the last entry (no conditions) is the default.
 14. **Trigger stats for idempotency**: Use \`stats.id\` and \`stats.key\` on the trigger when the workflow needs custom job IDs or indexed lookups:
 \`\`\`yaml
-trigger_x8kf:
+trigger_${suffix}:
   type: trigger
   stats:
     id: '{$self.input.data.workflowId}'
@@ -234,11 +235,11 @@ trigger_x8kf:
 
 ## Activity Manifest
 
-Along with the YAML, produce an activity_manifest array describing each activity. Note how all activity IDs share the same random suffix (\`_x8kf\`) for collision-proofing while remaining human-readable:
+Along with the YAML, produce an activity_manifest array describing each activity. Note how all activity IDs share the same random suffix (\`_${suffix}\`) for collision-proofing while remaining human-readable:
 \`\`\`json
 [
   {
-    "activity_id": "trigger_x8kf",
+    "activity_id": "trigger_${suffix}",
     "title": "Trigger",
     "type": "trigger",
     "tool_source": "trigger",
@@ -247,7 +248,7 @@ Along with the YAML, produce an activity_manifest array describing each activity
     "output_fields": ["url", "slug"]
   },
   {
-    "activity_id": "capture_x8kf",
+    "activity_id": "capture_${suffix}",
     "title": "Capture Page",
     "type": "worker",
     "tool_source": "mcp",
@@ -256,7 +257,7 @@ Along with the YAML, produce an activity_manifest array describing each activity
     "mcp_server_id": "long-tail-playwright-cli",
     "mcp_tool_name": "capture_page",
     "tool_arguments": {},
-    "input_mappings": { "url": "{trigger_x8kf.output.data.url}" },
+    "input_mappings": { "url": "{trigger_${suffix}.output.data.url}" },
     "output_fields": ["page_id", "path", "url", "title"]
   }
 ]
@@ -290,11 +291,11 @@ When the user provides answers to your questions, build the workflow immediately
 
 ## Output Format
 
-CRITICAL: The "name" field MUST match the "subscribes" topic in the YAML exactly. Use lowercase with dots as separators (e.g. "screenshot.analyze.store", "capture.page", "daily.report"). Dashes and underscores are also allowed but dots are preferred. The name and subscribes topic MUST be identical.
+CRITICAL: The "name" field MUST match the "subscribes" topic in the YAML exactly. Use snake_case (e.g. "screenshot_analyze_store", "capture_page", "daily_report"). Only lowercase letters, digits, and underscores. The name and subscribes topic MUST be identical.
 
 Return a JSON object (no markdown fences):
 {
-  "name": "screenshot.analyze.store",
+  "name": "screenshot_analyze_store",
   "description": "What this workflow does",
   "yaml": "<the complete YAML string>",
   "input_schema": { <JSON Schema for trigger inputs> },

package/build/system/workflows/mcp-workflow-planner/activities/persist.d.ts

@@ -3,7 +3,7 @@
  * These are side-effect functions that update the database.
  */
 import type { PlanItem, LTWorkflowSetStatus } from '../../../../types/workflow-set';
-export declare function persistPlan(setId: string, planItems: PlanItem[]): Promise<void>;
+export declare function persistPlan(setId: string, planItems: PlanItem[], namespaces?: string[]): Promise<void>;
 export interface BuiltWorkflowData {
     name: string;
     description: string;

package/build/system/workflows/mcp-workflow-planner/activities/persist.js

@@ -12,9 +12,9 @@ const workflow_sets_1 = require("../../../../services/workflow-sets");
 const db_1 = require("../../../../services/yaml-workflow/db");
 const deployer_1 = require("../../../../services/yaml-workflow/deployer");
 const workers_1 = require("../../../../services/yaml-workflow/workers");
-async function persistPlan(setId, planItems) {
-    const namespaces = [...new Set(planItems.map(w => w.namespace))];
-    await (0, workflow_sets_1.updateWorkflowSetPlan)(setId, planItems, namespaces);
+async function persistPlan(setId, planItems, namespaces) {
+    const ns = namespaces || [...new Set(planItems.map(w => w.namespace))];
+    await (0, workflow_sets_1.updateWorkflowSetPlan)(setId, planItems, ns);
 }
 async function persistBuiltWorkflow(setId, planItem, builderOutput) {
     const input = {

package/build/system/workflows/mcp-workflow-planner/index.js

@@ -51,14 +51,48 @@ const { generatePlan, persistPlan, persistBuiltWorkflow, updateSetStatus, deploy
  * and deploys the resulting set.
  */
 async function mcpWorkflowPlanner(envelope) {
-    const { specification, setId } = envelope.data;
+    const { specification, setId, existingPlan, existingSchemas, } = envelope.data;
+    const isAddition = !!existingPlan?.length;
     // 1. Generate plan from specification
-    const planResult = await generatePlan(specification);
-    // 2. Persist the plan to the workflow set
-    await persistPlan(setId, planResult.workflows);
+    // When adding to an existing set, tell the planner what already exists
+    let planSpec = specification;
+    if (isAddition) {
+        const existingNames = existingPlan.map(p => `- ${p.name} [${p.namespace}]: ${p.description}`).join('\n');
+        const namespaces = [...new Set(existingPlan.map(p => p.namespace))];
+        planSpec = `${specification}\n\n## Existing workflows in this set (do NOT recreate these):\n${existingNames}\n\n## Namespace constraint\nNew workflows MUST use namespace "${namespaces[0]}". This set already uses this namespace and all tools must be co-located.`;
+    }
+    const planResult = await generatePlan(planSpec);
+    // 2. Offset build_order for additions so new items sort after existing ones
+    const buildOrderOffset = isAddition
+        ? Math.max(...existingPlan.map((_, i) => i), 0) + 1
+        : 0;
+    if (isAddition) {
+        for (const item of planResult.workflows) {
+            item.build_order += buildOrderOffset;
+        }
+    }
+    // 2b. Persist plan — append to existing plan for additions
+    if (isAddition) {
+        // Fetch current plan from the set and merge
+        const { getWorkflowSet } = await Promise.resolve().then(() => __importStar(require('../../../services/workflow-sets')));
+        const currentSet = await getWorkflowSet(setId);
+        const mergedPlan = [...(currentSet?.plan || []), ...planResult.workflows];
+        const mergedNamespaces = [...new Set([
+                ...(currentSet?.namespaces || []),
+                ...planResult.workflows.map(w => w.namespace),
+            ])];
+        await persistPlan(setId, mergedPlan, mergedNamespaces);
+    }
+    else {
+        await persistPlan(setId, planResult.workflows);
+    }
     // 3. Build each workflow in dependency order (leaf-first)
     await updateSetStatus(setId, 'building');
-    const builtWorkflows = [];
+    // Seed sibling schemas with existing workflows when adding to a set
+    const builtWorkflows = (existingSchemas || []).map(s => ({
+        ...s,
+        id: '',
+    }));
     for (const planItem of planResult.workflows) {
         // Build context for the builder: sibling schemas for composition wiring
         const siblingSchemas = builtWorkflows.map(w => ({