@sweny-ai/core 0.1.78 → 0.1.80

package/dist/executor.js

@@ -17,6 +17,7 @@ import { resolveSources } from "./source-resolver.js";
 import { evaluateVerify } from "./verify.js";
 import { evaluateRequires } from "./requires.js";
 import { buildRetryPreamble } from "./retry.js";
+import { buildToolAliases } from "./skills/index.js";
 /**
  * Execute a workflow from entry to completion.
  *
@@ -37,6 +38,10 @@ export async function execute(workflow, input, options) {
     const nodeRunCounts = new Map(); // node → times executed
     const trace = { steps: [], edges: [], sources: {} };
     validate(workflow, skills);
+    // Build a verify-time alias table from the loaded skills. Each skill owns
+    // its own mapping between skill-tool names and equivalent MCP names. Core
+    // stays vendor-neutral — this call just unions what the skills declare.
+    const toolAliases = buildToolAliases(skills.values(), logger);
     // ── Source resolution phase ─────────────────────────────────────
     // Resolve all Source values (node instructions + rules/context at every
     // level) into plain text before the main execution loop. This eagerly
@@ -159,7 +164,7 @@ export async function execute(workflow, input, options) {
             // Retry only triggers on verify failure — bail on tool/API errors.
             if (result.status !== "success")
                 break;
-            const verifyError = evaluateVerify(node.verify, result);
+            const verifyError = evaluateVerify(node.verify, result, toolAliases);
             if (!verifyError)
                 break;
             // Apply verify failure to the result.

package/dist/schema.d.ts

@@ -236,6 +236,7 @@ export declare const skillZ: z.ZodEffects<z.ZodObject<{
         command?: string | undefined;
         args?: string[] | undefined;
     }>>;
+    mcpAliases: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
 }, "strip", z.ZodTypeAny, {
     id: string;
     name: string;
@@ -260,6 +261,7 @@ export declare const skillZ: z.ZodEffects<z.ZodObject<{
         command?: string | undefined;
         args?: string[] | undefined;
     } | undefined;
+    mcpAliases?: Record<string, string[]> | undefined;
 }, {
     id: string;
     name: string;
@@ -284,6 +286,7 @@ export declare const skillZ: z.ZodEffects<z.ZodObject<{
         description: string;
         input_schema: Record<string, unknown>;
     }[] | undefined;
+    mcpAliases?: Record<string, string[]> | undefined;
 }>, {
     id: string;
     name: string;
@@ -308,6 +311,7 @@ export declare const skillZ: z.ZodEffects<z.ZodObject<{
         command?: string | undefined;
         args?: string[] | undefined;
     } | undefined;
+    mcpAliases?: Record<string, string[]> | undefined;
 }, {
     id: string;
     name: string;
@@ -332,6 +336,7 @@ export declare const skillZ: z.ZodEffects<z.ZodObject<{
         description: string;
         input_schema: Record<string, unknown>;
     }[] | undefined;
+    mcpAliases?: Record<string, string[]> | undefined;
 }>;
 /**
  * NodeSources: either an array of Sources (additive — inherits cascade)

package/dist/schema.js

@@ -61,6 +61,7 @@ export const skillZ = z
     tools: z.array(toolZ).default([]),
     instruction: z.string().optional(),
     mcp: mcpServerConfigZ.optional(),
+    mcpAliases: z.record(z.array(z.string().min(1)).min(1)).optional(),
 })
     .refine((s) => s.tools.length > 0 || s.instruction || s.mcp, {
     message: "Skill must provide at least one of: tools, instruction, or mcp",

package/dist/skills/github.js

@@ -183,4 +183,21 @@ export const github = {
             },
         },
     ],
+    // Equivalent tool names on GitHub's official MCP server
+    // (github.com/github/github-mcp-server). Aliases declared for every
+    // GitHub MCP name that does NOT also exist on Linear's MCP. The
+    // executor's buildToolAliases already drops any name claimed by more
+    // than one loaded skill, so these declarations are safe even if a
+    // future provider starts using the same name — declare what this
+    // skill knows, let the runtime resolve conflicts.
+    //
+    // Names that currently exist on both Linear and GitHub MCPs and are
+    // therefore intentionally NOT aliased on either side: `get_issue`,
+    // `list_issues`.
+    mcpAliases: {
+        github_create_pr: ["create_pull_request"],
+        github_add_comment: ["add_issue_comment"],
+        github_create_issue: ["create_issue"],
+        github_search_issues: ["search_issues"],
+    },
 };

package/dist/skills/index.d.ts

@@ -7,7 +7,7 @@
  * Custom skill discovery (filesystem-based) lives in `./custom-loader.js`,
  * which is Node-only and re-exported from `@sweny-ai/core` (the Node entry).
  */
-import type { Skill, SkillCategory } from "../types.js";
+import type { Logger, Skill, SkillCategory } from "../types.js";
 import { github } from "./github.js";
 import { linear } from "./linear.js";
 import { slack } from "./slack.js";
@@ -86,3 +86,24 @@ export declare function validateWorkflowSkills(workflow: {
         skills: string[];
     }>;
 }, available: Map<string, Skill>, inlineSkills?: Record<string, InlineSkillDef>): SkillValidationResult;
+/**
+ * Build a symmetric tool-name alias table from the loaded skills.
+ *
+ * Each skill declares its own `mcpAliases` (canonical name → list of
+ * equivalent MCP tool names). This function:
+ *
+ *   1. Collects every alias pair declared by every loaded skill.
+ *   2. Flattens each pair into one equivalence group (symmetric closure).
+ *   3. Drops any MCP name claimed by more than one skill (ambiguous).
+ *
+ * Core stays vendor-neutral: nothing here knows Linear or GitHub by name.
+ * Skills own their own naming, and ambiguity is detected at map-build
+ * time so a call to one provider's `get_issue` can never spuriously
+ * satisfy another provider's `any_tool_called` verify rule.
+ *
+ * @returns a map from every participating name to the full set of names
+ *   that count as equivalent to it (including itself). Names that do not
+ *   participate in any alias are absent — callers should fall back to
+ *   name-equality when a lookup returns `undefined`.
+ */
+export declare function buildToolAliases(skills: Iterable<Skill>, logger?: Logger): ReadonlyMap<string, ReadonlySet<string>>;

package/dist/skills/index.js

@@ -144,3 +144,94 @@ export function validateWorkflowSkills(workflow, available, inlineSkills) {
     }
     return { configured, missing, errors, warnings };
 }
+/**
+ * Build a symmetric tool-name alias table from the loaded skills.
+ *
+ * Each skill declares its own `mcpAliases` (canonical name → list of
+ * equivalent MCP tool names). This function:
+ *
+ *   1. Collects every alias pair declared by every loaded skill.
+ *   2. Flattens each pair into one equivalence group (symmetric closure).
+ *   3. Drops any MCP name claimed by more than one skill (ambiguous).
+ *
+ * Core stays vendor-neutral: nothing here knows Linear or GitHub by name.
+ * Skills own their own naming, and ambiguity is detected at map-build
+ * time so a call to one provider's `get_issue` can never spuriously
+ * satisfy another provider's `any_tool_called` verify rule.
+ *
+ * @returns a map from every participating name to the full set of names
+ *   that count as equivalent to it (including itself). Names that do not
+ *   participate in any alias are absent — callers should fall back to
+ *   name-equality when a lookup returns `undefined`.
+ */
+export function buildToolAliases(skills, logger) {
+    // First pass: record which skill(s) claim each MCP alias name.
+    const mcpClaims = new Map(); // mcp name → skill ids that declared it
+    const pairs = []; // [canonical, mcpAlias]
+    for (const skill of skills) {
+        if (!skill.mcpAliases)
+            continue;
+        for (const [canonical, aliases] of Object.entries(skill.mcpAliases)) {
+            for (const alias of aliases) {
+                if (canonical === alias)
+                    continue;
+                pairs.push([canonical, alias]);
+                const claimers = mcpClaims.get(alias);
+                if (claimers) {
+                    if (!claimers.includes(skill.id))
+                        claimers.push(skill.id);
+                }
+                else {
+                    mcpClaims.set(alias, [skill.id]);
+                }
+            }
+        }
+    }
+    // Drop ambiguous MCP names (claimed by >1 skill) and log once.
+    const ambiguous = new Set();
+    for (const [name, claimers] of mcpClaims) {
+        if (claimers.length > 1) {
+            ambiguous.add(name);
+            logger?.warn(`Tool alias "${name}" is declared by multiple skills (${claimers.join(", ")}); dropping from verify alias table to avoid cross-provider false positives.`);
+        }
+    }
+    // Second pass: union-find over the remaining pairs.
+    const parent = new Map();
+    const find = (x) => {
+        let cur = parent.get(x) ?? x;
+        while (cur !== (parent.get(cur) ?? cur))
+            cur = parent.get(cur) ?? cur;
+        parent.set(x, cur);
+        return cur;
+    };
+    const union = (a, b) => {
+        const ra = find(a);
+        const rb = find(b);
+        if (ra !== rb)
+            parent.set(ra, rb);
+    };
+    // `find` registers previously-unseen nodes via `parent.get(x) ?? x` and
+    // writes them back, so `union` handles first-contact pairs on its own.
+    for (const [canonical, alias] of pairs) {
+        if (ambiguous.has(alias))
+            continue;
+        union(canonical, alias);
+    }
+    // Build the result: each name → its full equivalence set.
+    const groups = new Map();
+    for (const name of parent.keys()) {
+        const root = find(name);
+        let group = groups.get(root);
+        if (!group) {
+            group = new Set();
+            groups.set(root, group);
+        }
+        group.add(name);
+    }
+    const result = new Map();
+    for (const group of groups.values()) {
+        for (const name of group)
+            result.set(name, group);
+    }
+    return result;
+}

package/dist/skills/linear.js

@@ -144,4 +144,24 @@ export const linear = {
             },
         },
     ],
+    // Equivalent tool names on Linear's official remote MCP server (mcp.linear.app).
+    //
+    // Linear's MCP uses upsert naming: a single `save_issue` handles both
+    // create and update. The executor builds symmetric equivalence groups, so
+    // both `linear_create_issue` and `linear_update_issue` end up in one group
+    // with `save_issue`. A `save_issue` call satisfies verify rules for either
+    // canonical name — verify cannot distinguish create from update when the
+    // agent uses the remote MCP. That reflects the provider's reality, not a
+    // shortcoming of the alias layer.
+    //
+    // Names that also exist on GitHub's MCP server (`get_issue`, `list_issues`,
+    // `get_team`) are left out. `buildToolAliases` also drops any MCP name
+    // claimed by more than one loaded skill as a defensive backstop.
+    mcpAliases: {
+        linear_create_issue: ["save_issue"],
+        linear_update_issue: ["save_issue"],
+        linear_search_issues: ["list_issues"],
+        linear_add_comment: ["save_comment"],
+        linear_list_teams: ["list_teams"],
+    },
 };

package/dist/types.d.ts

@@ -36,6 +36,25 @@ export interface Skill {
     instruction?: string;
     /** External MCP server definition wired for nodes referencing this skill. */
     mcp?: McpServerConfig;
+    /**
+     * Tool-name aliases recognized by `verify`.
+     *
+     * When a workflow references `any_tool_called: [linear_create_issue]` and
+     * the agent instead calls the equivalent MCP tool exposed by this skill's
+     * MCP server (e.g. `save_issue` on Linear's remote MCP), the two names
+     * should count as equivalent. Each skill owns the mapping for its own
+     * domain — core stays vendor-neutral.
+     *
+     * Key: a canonical tool name (usually one of this skill's `tools[].name`,
+     * but any name the skill wants to equate is valid).
+     * Value: list of equivalent names, typically tool names exposed by this
+     * skill's external MCP server.
+     *
+     * Aliases are symmetric: a verify rule naming either side matches a call
+     * on either side. Omit names that are ambiguous across providers
+     * (e.g. `get_issue` is exposed by both Linear and GitHub MCP servers).
+     */
+    mcpAliases?: Record<string, string[]>;
 }
 /**
  * Per-node rules or context.

package/dist/verify.d.ts

@@ -9,9 +9,10 @@ export type Resolution = {
 };
 export declare function resolvePath(data: unknown, path: string): Resolution;
 export declare function isErrorOutput(output: unknown): boolean;
-export declare function checkAnyToolCalled(required: string[], toolCalls: ToolCall[]): string | null;
-export declare function checkAllToolsCalled(required: string[], toolCalls: ToolCall[]): string | null;
-export declare function checkNoToolCalled(forbidden: string[], toolCalls: ToolCall[]): string | null;
+export type ToolAliases = ReadonlyMap<string, ReadonlySet<string>>;
+export declare function checkAnyToolCalled(required: string[], toolCalls: ToolCall[], aliases?: ToolAliases): string | null;
+export declare function checkAllToolsCalled(required: string[], toolCalls: ToolCall[], aliases?: ToolAliases): string | null;
+export declare function checkNoToolCalled(forbidden: string[], toolCalls: ToolCall[], aliases?: ToolAliases): string | null;
 export declare function checkOutputRequired(paths: string[], data: unknown): string | null;
 export declare function checkOutputMatches(matches: OutputMatch[], data: unknown): string | null;
 /**
@@ -21,4 +22,4 @@ export declare function checkOutputMatches(matches: OutputMatch[], data: unknown
  * Deterministic and side-effect free — the executor calls this synchronously
  * after the LLM finishes.
  */
-export declare function evaluateVerify(verify: NodeVerify | undefined, result: NodeResult): string | null;
+export declare function evaluateVerify(verify: NodeVerify | undefined, result: NodeResult, aliases?: ToolAliases): string | null;

package/dist/verify.js

@@ -105,22 +105,32 @@ function succeededTools(toolCalls) {
 function calledList(toolCalls) {
     return toolCalls.map((c) => c.tool).join(", ") || "none";
 }
-export function checkAnyToolCalled(required, toolCalls) {
+function expandAliases(name, aliases) {
+    return aliases?.get(name) ?? new Set([name]);
+}
+function anyAliasIn(name, set, aliases) {
+    for (const alias of expandAliases(name, aliases)) {
+        if (set.has(alias))
+            return true;
+    }
+    return false;
+}
+export function checkAnyToolCalled(required, toolCalls, aliases) {
     const succeeded = succeededTools(toolCalls);
-    if (required.some((t) => succeeded.has(t)))
+    if (required.some((t) => anyAliasIn(t, succeeded, aliases)))
         return null;
     return `any_tool_called: required one of [${required.join(", ")}] to succeed, called: [${calledList(toolCalls)}]`;
 }
-export function checkAllToolsCalled(required, toolCalls) {
+export function checkAllToolsCalled(required, toolCalls, aliases) {
     const succeeded = succeededTools(toolCalls);
-    const missing = required.filter((t) => !succeeded.has(t));
+    const missing = required.filter((t) => !anyAliasIn(t, succeeded, aliases));
     if (missing.length === 0)
         return null;
     return `all_tools_called: missing successful calls to [${missing.join(", ")}], called: [${calledList(toolCalls)}]`;
 }
-export function checkNoToolCalled(forbidden, toolCalls) {
+export function checkNoToolCalled(forbidden, toolCalls, aliases) {
     const calledNames = new Set(toolCalls.map((c) => c.tool));
-    const violated = forbidden.filter((t) => calledNames.has(t));
+    const violated = forbidden.filter((t) => anyAliasIn(t, calledNames, aliases));
     if (violated.length === 0)
         return null;
     return `no_tool_called: forbidden tools were invoked: [${violated.join(", ")}], called: [${calledList(toolCalls)}]`;
@@ -312,22 +322,22 @@ function describeOperator(c) {
  * Deterministic and side-effect free — the executor calls this synchronously
  * after the LLM finishes.
  */
-export function evaluateVerify(verify, result) {
+export function evaluateVerify(verify, result, aliases) {
     if (!verify)
         return null;
     const failures = [];
     if (verify.any_tool_called && verify.any_tool_called.length > 0) {
-        const e = checkAnyToolCalled(verify.any_tool_called, result.toolCalls);
+        const e = checkAnyToolCalled(verify.any_tool_called, result.toolCalls, aliases);
         if (e)
             failures.push(e);
     }
     if (verify.all_tools_called && verify.all_tools_called.length > 0) {
-        const e = checkAllToolsCalled(verify.all_tools_called, result.toolCalls);
+        const e = checkAllToolsCalled(verify.all_tools_called, result.toolCalls, aliases);
         if (e)
             failures.push(e);
     }
     if (verify.no_tool_called && verify.no_tool_called.length > 0) {
-        const e = checkNoToolCalled(verify.no_tool_called, result.toolCalls);
+        const e = checkNoToolCalled(verify.no_tool_called, result.toolCalls, aliases);
         if (e)
             failures.push(e);
     }

package/package.json

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