@sweny-ai/core 0.1.126 → 0.1.128

package/dist/claude.d.ts

@@ -78,7 +78,9 @@ export interface ClaudeClientOptions {
     logger?: Logger;
     /** Default tool context for standalone usage (not via executor) */
     defaultContext?: ToolContext;
-    /** External MCP servers (GitHub, Linear, Sentry, etc.) — merged with core skill tools */
+    /** Catalog defaults, overridden by per-run skill servers and explicit mcpServers. */
+    defaultMcpServers?: Record<string, McpServerConfig>;
+    /** Explicit external MCP servers, overriding defaults and per-run skill servers. */
     mcpServers?: Record<string, McpServerConfig>;
     /**
      * Extra env var names passed to the agent subprocess on top of the
@@ -123,6 +125,7 @@ export declare class ClaudeClient implements Claude {
     private logger;
     private defaultContext;
     private mcpServers;
+    private defaultMcpServers;
     private envPassthrough;
     private sandboxMode;
     private sandboxAllowedDomains;
@@ -153,6 +156,8 @@ export declare class ClaudeClient implements Claude {
         timeoutMs?: number;
         /** Caller-supplied abort signal. Aborting it interrupts the query. */
         signal?: AbortSignal;
+        /** MCP servers declared by the current node's skills. */
+        mcpServers?: Record<string, McpServerConfig>;
         /** Dry run (#380): no external MCP servers, no write-capable built-ins. */
         readOnly?: boolean;
         /** Env var names + sandbox hosts this node's skills need (#360). */

package/dist/claude.js

@@ -211,6 +211,7 @@ export class ClaudeClient {
     logger;
     defaultContext;
     mcpServers;
+    defaultMcpServers;
     envPassthrough;
     sandboxMode;
     sandboxAllowedDomains;
@@ -224,6 +225,7 @@ export class ClaudeClient {
         this.logger = opts.logger ?? consoleLogger;
         this.defaultContext = opts.defaultContext ?? { config: {}, logger: this.logger };
         this.mcpServers = opts.mcpServers ?? {};
+        this.defaultMcpServers = opts.defaultMcpServers ?? {};
         this.envPassthrough = opts.envPassthrough;
         this.envScope = opts.envScope;
         this.sandboxMode = opts.sandbox;
@@ -339,7 +341,9 @@ export class ClaudeClient {
         const abort = makeAbort(timeoutMs, signal);
         let stream;
         try {
-            const allMcpServers = readOnly ? {} : { ...this.mcpServers };
+            const allMcpServers = readOnly
+                ? {}
+                : { ...this.defaultMcpServers, ...opts.mcpServers, ...this.mcpServers };
             if (sdkTools.length > 0)
                 allMcpServers["sweny-core"] = mcpServer;
             stream = query({

package/dist/cli/main.js

@@ -204,7 +204,8 @@ triageCmd.action(async (options) => {
         maxTurns: config.maxInvestigateTurns || 50,
         cwd: process.cwd(),
         logger: consoleLogger,
-        mcpServers,
+        defaultMcpServers: mcpServers,
+        mcpServers: config.mcpServers,
     });
     // ── Progress display state ─────────────────────────────────
     const FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
@@ -513,7 +514,8 @@ implementCmd.action(async (issueId, options) => {
         maxTurns: config.maxImplementTurns || 40,
         cwd: process.cwd(),
         logger: consoleLogger,
-        mcpServers,
+        defaultMcpServers: mcpServers,
+        mcpServers: config.mcpServers,
     });
     console.log(chalk.cyan(`\n  sweny implement ${issueId}\n`));
     const implRunStart = Date.now();
@@ -756,7 +758,8 @@ export async function workflowRunAction(file, options) {
         maxTurns: config.maxInvestigateTurns || 50,
         cwd: process.cwd(),
         logger: runLogger,
-        mcpServers,
+        defaultMcpServers: mcpServers,
+        mcpServers: config.mcpServers,
         model: workflow.model,
     });
     // Track per-node entry time to compute elapsed on exit

package/dist/executor.js

@@ -148,12 +148,16 @@ export async function execute(workflow, input, options) {
             logger.info(`  dry run: withheld write tools: ${skippedWrites.join(", ")}`, { node: currentId });
         }
         const skillInstructions = resolveSkillInstructions(node.skills, skills);
+        const skillMcpServers = resolveSkillMcpServers(node.skills, skills);
         // Runtime guard: if this node declares skills but none resolved, the node
         // cannot do its job (e.g. "create a Linear issue" with no linear skill).
         // The startup validate() warns about this possibility, but only throw when
         // the node is actually reached — unreachable nodes with missing skills are fine.
-        // Instruction-only skills (no tools) are valid — they inject context into the prompt.
-        if (node.skills.length > 0 && resolvedSkillTools.length === 0 && skillInstructions.length === 0) {
+        // Instruction-only and resolved MCP-only skills are valid capabilities.
+        if (node.skills.length > 0 &&
+            resolvedSkillTools.length === 0 &&
+            skillInstructions.length === 0 &&
+            Object.keys(skillMcpServers).length === 0) {
             throw new Error(`Node "${currentId}" requires skills [${node.skills.join(", ")}] but none are configured. ` +
                 `Set the required environment variables and try again.`);
         }
@@ -241,6 +245,7 @@ export async function execute(workflow, input, options) {
                 signal,
                 timeoutMs,
                 agentAccess: resolveAgentAccess(node.skills, skills),
+                ...(dryRun ? {} : { mcpServers: skillMcpServers }),
                 ...(dryRun ? { readOnly: true } : {}),
                 onProgress: (message) => {
                     safeObserve(observer, { type: "node:progress", node: currentId, message }, logger);
@@ -721,6 +726,13 @@ function dryRunNotice(skippedWrites) {
         `Do not create, modify, post, or send anything. Do the analysis, and where this step would ` +
         `normally write, describe exactly what it would have written instead.`);
 }
+/** Only this node's resolved skills contribute external servers. */
+function resolveSkillMcpServers(skillIds, skills) {
+    return Object.fromEntries(skillIds.flatMap((id) => {
+        const mcp = skills.get(id)?.mcp;
+        return mcp ? [[id, { ...mcp, type: mcp.type ?? (mcp.command ? "stdio" : "http") }]] : [];
+    }));
+}
 function resolveTools(skillIds, skills) {
     return skillIds
         .map((id) => skills.get(id))
@@ -1023,6 +1035,14 @@ async function resolveNext(workflow, current, results, input, claude, observer,
  * Validate a workflow definition before execution.
  */
 function validate(workflow, skills) {
+    for (const [id, def] of Object.entries(workflow.skills ?? {})) {
+        if (!def.instruction?.trim()) {
+            throw new Error(`Inline skill "${id}" must provide a non-empty instruction`);
+        }
+        if (id === "sweny-core" && def.mcp) {
+            throw new Error(`Skill "sweny-core" is reserved for the engine MCP server; use a different skill ID`);
+        }
+    }
     if (!workflow.nodes[workflow.entry]) {
         throw new Error(`Entry node "${workflow.entry}" not found`);
     }
@@ -1036,6 +1056,12 @@ function validate(workflow, skills) {
     for (const [nodeId, node] of Object.entries(workflow.nodes)) {
         if (node.skills.length === 0)
             continue;
+        for (const id of node.skills) {
+            const skill = skills.get(id);
+            if (id === "sweny-core" && skill?.mcp) {
+                throw new Error(`Skill "sweny-core" is reserved for the engine MCP server; use a different skill ID (node "${nodeId}")`);
+            }
+        }
         const available = node.skills.filter((id) => skills.has(id));
         if (available.length === 0) {
             consoleLogger.warn(`Node "${nodeId}" has no available skills (needs one of: ${node.skills.join(", ")})`);

package/dist/schema.d.ts

@@ -3357,11 +3357,7 @@ export declare const workflowJsonSchema: {
             readonly description: "Inline skill definitions scoped to this workflow";
             readonly additionalProperties: {
                 readonly type: "object";
-                readonly anyOf: readonly [{
-                    readonly required: readonly ["instruction"];
-                }, {
-                    readonly required: readonly ["mcp"];
-                }];
+                readonly required: readonly ["instruction"];
                 readonly additionalProperties: false;
                 readonly properties: {
                     readonly name: {
@@ -3372,6 +3368,7 @@ export declare const workflowJsonSchema: {
                     };
                     readonly instruction: {
                         readonly type: "string";
+                        readonly pattern: "\\S";
                         readonly description: "Natural language expertise injected into the node prompt";
                     };
                     readonly mcp: {

package/dist/schema.js

@@ -63,8 +63,8 @@ export const skillDefinitionZ = z
     mcp: mcpServerConfigZ.optional(),
 })
     .strict()
-    .refine((s) => s.instruction || s.mcp, {
-    message: "Inline skill must provide instruction, mcp, or both",
+    .refine((s) => Boolean(s.instruction?.trim()), {
+    message: "Inline skill must provide a non-empty instruction",
 });
 export const skillZ = z
     .object({
@@ -489,12 +489,18 @@ export function validateWorkflow(workflow, knownSkills) {
             });
         }
     }
-    // Inline skill definitions must have instruction or mcp
+    // Inline skills need usage instructions; the engine server name is reserved.
     for (const [skillId, def] of Object.entries(workflow.skills ?? {})) {
-        if (!def.instruction && !def.mcp) {
+        if (!def.instruction?.trim()) {
             errors.push({
                 code: "INVALID_INLINE_SKILL",
-                message: `Inline skill "${skillId}" must provide at least instruction or mcp`,
+                message: `Inline skill "${skillId}" must provide a non-empty instruction`,
+            });
+        }
+        if (skillId === "sweny-core" && def.mcp) {
+            errors.push({
+                code: "INVALID_INLINE_SKILL",
+                message: `Skill "sweny-core" is reserved for the engine MCP server; use a different skill ID`,
             });
         }
     }
@@ -945,14 +951,18 @@ export const workflowJsonSchema = {
             description: "Inline skill definitions scoped to this workflow",
             additionalProperties: {
                 type: "object",
-                // Fix #4: an inline skill must provide instruction, mcp, or both.
-                anyOf: [{ required: ["instruction"] }, { required: ["mcp"] }],
+                // Inline skills need usable instructions, including when they declare MCP.
+                required: ["instruction"],
                 // Round 2: reject unknown keys to match Zod skillDefinitionZ.strict().
                 additionalProperties: false,
                 properties: {
                     name: { type: "string" },
                     description: { type: "string" },
-                    instruction: { type: "string", description: "Natural language expertise injected into the node prompt" },
+                    instruction: {
+                        type: "string",
+                        pattern: "\\S",
+                        description: "Natural language expertise injected into the node prompt",
+                    },
                     mcp: {
                         type: "object",
                         description: "External MCP server definition",

package/dist/types.d.ts

@@ -604,6 +604,8 @@ export interface Claude {
         outputSchema?: JSONSchema;
         /** Called with status messages while Claude is working (tool name, etc.) */
         onProgress?: (message: string) => void;
+        /** MCP servers declared by this node's resolved skills. Explicit client configs win. */
+        mcpServers?: Record<string, McpServerConfig>;
         /** Per-node turn limit. Overrides the client default when set. */
         maxTurns?: number;
         /** Built-in SDK tool names to disallow for this node (e.g. ["Bash"]). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.126",
+  "version": "0.1.128",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"