@sweny-ai/core 0.1.0

package/dist/__tests__/integration/e2e-workflow.integration.test.js

@@ -0,0 +1,75 @@
+import { describe, it, expect } from "vitest";
+import { available, logAvailability } from "./harness.js";
+import { execute } from "../../executor.js";
+import { ClaudeClient } from "../../claude.js";
+import { createSkillMap } from "../../skills/index.js";
+logAvailability();
+// A minimal 2-node workflow that only uses Claude (no external tools)
+const analysisWorkflow = {
+    id: "e2e-analysis",
+    name: "E2E Analysis",
+    description: "Two-node workflow using real Claude",
+    entry: "analyze",
+    nodes: {
+        analyze: {
+            name: "Analyze Input",
+            instruction: "Analyze the input data and determine if it represents a critical issue. Return JSON with fields: severity (high/medium/low) and summary (one sentence).",
+            skills: [],
+            output: {
+                type: "object",
+                properties: {
+                    severity: { type: "string", enum: ["high", "medium", "low"] },
+                    summary: { type: "string" },
+                },
+                required: ["severity", "summary"],
+            },
+        },
+        report: {
+            name: "Generate Report",
+            instruction: "Based on the analysis, write a brief incident report. Return JSON with fields: title (string) and recommendation (string).",
+            skills: [],
+            output: {
+                type: "object",
+                properties: {
+                    title: { type: "string" },
+                    recommendation: { type: "string" },
+                },
+                required: ["title", "recommendation"],
+            },
+        },
+    },
+    edges: [{ from: "analyze", to: "report" }],
+};
+describe.runIf(available.claude)("e2e workflow with real Claude", () => {
+    it("executes a 2-node analysis workflow", async () => {
+        const claude = new ClaudeClient({
+            model: "claude-haiku-4-5-20251001", // Use Haiku for speed/cost in tests
+            maxTurns: 3,
+        });
+        const events = [];
+        const results = await execute(analysisWorkflow, {
+            alert: "CPU usage at 98% for 15 minutes on production server web-03",
+            service: "api-gateway",
+            timestamp: "2025-03-25T08:00:00Z",
+        }, {
+            skills: createSkillMap([]),
+            claude,
+            observer: (e) => events.push(e),
+            config: {},
+        });
+        // Both nodes executed
+        expect(results.size).toBe(2);
+        expect(results.get("analyze")?.status).toBe("success");
+        expect(results.get("report")?.status).toBe("success");
+        // Analysis should have severity
+        const analysis = results.get("analyze").data;
+        expect(analysis).toBeDefined();
+        // Report should have title
+        const report = results.get("report").data;
+        expect(report).toBeDefined();
+        // Events stream should be complete
+        expect(events[0].type).toBe("workflow:start");
+        expect(events[events.length - 1].type).toBe("workflow:end");
+        expect(events.filter((e) => e.type === "node:enter")).toHaveLength(2);
+    }, 60_000); // 60s timeout for real API calls
+});

package/dist/__tests__/integration/github.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/integration/github.integration.test.js

@@ -0,0 +1,37 @@
+import { describe, it, expect } from "vitest";
+import { available, logAvailability } from "./harness.js";
+import { github } from "../../skills/github.js";
+logAvailability();
+const ctx = () => ({
+    config: { GITHUB_TOKEN: process.env.GITHUB_TOKEN },
+    logger: console,
+});
+describe.runIf(available.github)("github integration", () => {
+    it("searches code in a public repo", async () => {
+        const tool = github.tools.find((t) => t.name === "github_search_code");
+        const result = await tool.handler({ query: "README", repo: "octocat/Hello-World" }, ctx());
+        expect(result).toHaveProperty("items");
+    }, 15_000);
+    it("gets an issue from a public repo", async () => {
+        const tool = github.tools.find((t) => t.name === "github_get_issue");
+        const result = await tool.handler({ repo: "octocat/Hello-World", number: 1 }, ctx());
+        expect(result).toHaveProperty("title");
+        expect(result).toHaveProperty("state");
+    }, 15_000);
+    it("lists recent commits", async () => {
+        const tool = github.tools.find((t) => t.name === "github_list_recent_commits");
+        const result = await tool.handler({ repo: "octocat/Hello-World", branch: "master", per_page: 3 }, ctx());
+        expect(Array.isArray(result)).toBe(true);
+        expect(result.length).toBeGreaterThan(0);
+    }, 15_000);
+    it("searches issues", async () => {
+        const tool = github.tools.find((t) => t.name === "github_search_issues");
+        const result = await tool.handler({ query: "is:issue", repo: "octocat/Hello-World" }, ctx());
+        expect(result).toHaveProperty("items");
+    }, 15_000);
+    it("gets a file from a public repo", async () => {
+        const tool = github.tools.find((t) => t.name === "github_get_file");
+        const result = await tool.handler({ repo: "octocat/Hello-World", path: "README" }, ctx());
+        expect(result).toHaveProperty("content");
+    }, 15_000);
+});

package/dist/__tests__/integration/harness.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Integration Test Harness
+ *
+ * Detects which external services are available via environment variables.
+ * Integration tests use `describe.runIf(available.xxx)` to skip cleanly
+ * when credentials aren't present.
+ *
+ * Usage:
+ *   npx vitest run --config vitest.integration.config.ts
+ *
+ * Or with env vars:
+ *   GITHUB_TOKEN=ghp_... npx vitest run --config vitest.integration.config.ts
+ */
+export declare const available: {
+    github: boolean;
+    linear: boolean;
+    sentry: boolean;
+    datadog: boolean;
+    slack: boolean;
+    discord: boolean;
+    claude: boolean;
+};
+/** Print which services are available (for CI logs) */
+export declare function logAvailability(): void;

package/dist/__tests__/integration/harness.js

@@ -0,0 +1,34 @@
+/**
+ * Integration Test Harness
+ *
+ * Detects which external services are available via environment variables.
+ * Integration tests use `describe.runIf(available.xxx)` to skip cleanly
+ * when credentials aren't present.
+ *
+ * Usage:
+ *   npx vitest run --config vitest.integration.config.ts
+ *
+ * Or with env vars:
+ *   GITHUB_TOKEN=ghp_... npx vitest run --config vitest.integration.config.ts
+ */
+export const available = {
+    github: !!process.env.GITHUB_TOKEN,
+    linear: !!process.env.LINEAR_API_KEY,
+    sentry: !!(process.env.SENTRY_AUTH_TOKEN && process.env.SENTRY_ORG),
+    datadog: !!(process.env.DD_API_KEY && process.env.DD_APP_KEY),
+    slack: !!(process.env.SLACK_WEBHOOK_URL || process.env.SLACK_BOT_TOKEN),
+    discord: !!process.env.DISCORD_WEBHOOK_URL,
+    claude: !!process.env.ANTHROPIC_API_KEY,
+};
+/** Print which services are available (for CI logs) */
+export function logAvailability() {
+    const entries = Object.entries(available);
+    const on = entries.filter(([, v]) => v).map(([k]) => k);
+    const off = entries.filter(([, v]) => !v).map(([k]) => k);
+    console.log(`\n🔌 Integration test services:`);
+    if (on.length > 0)
+        console.log(`   ✅ Available: ${on.join(", ")}`);
+    if (off.length > 0)
+        console.log(`   ⏭️  Skipped:   ${off.join(", ")}`);
+    console.log();
+}

package/dist/__tests__/integration/linear.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/integration/linear.integration.test.js

@@ -0,0 +1,15 @@
+import { describe, it, expect } from "vitest";
+import { available } from "./harness.js";
+import { linear } from "../../skills/linear.js";
+const ctx = () => ({
+    config: { LINEAR_API_KEY: process.env.LINEAR_API_KEY },
+    logger: console,
+});
+describe.runIf(available.linear)("linear integration", () => {
+    it("searches issues", async () => {
+        const tool = linear.tools.find((t) => t.name === "linear_search_issues");
+        const result = await tool.handler({ query: "bug", limit: 3 }, ctx());
+        expect(result).toHaveProperty("searchIssues");
+        expect(result.searchIssues).toHaveProperty("nodes");
+    }, 15_000);
+});

package/dist/__tests__/integration/sentry.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/integration/sentry.integration.test.js

@@ -0,0 +1,20 @@
+import { describe, it, expect } from "vitest";
+import { available } from "./harness.js";
+import { sentry } from "../../skills/sentry.js";
+const ctx = () => ({
+    config: {
+        SENTRY_AUTH_TOKEN: process.env.SENTRY_AUTH_TOKEN,
+        SENTRY_ORG: process.env.SENTRY_ORG,
+        SENTRY_BASE_URL: process.env.SENTRY_BASE_URL ?? "",
+    },
+    logger: console,
+});
+describe.runIf(available.sentry)("sentry integration", () => {
+    // These tests require at least one project in the org
+    it("list_issues returns an array", async () => {
+        const tool = sentry.tools.find((t) => t.name === "sentry_list_issues");
+        // Use the first project found, or skip if none
+        const result = await tool.handler({ project: process.env.SENTRY_PROJECT ?? "javascript" }, ctx());
+        expect(Array.isArray(result)).toBe(true);
+    }, 15_000);
+});

package/dist/__tests__/integration/slack.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/integration/slack.integration.test.js

@@ -0,0 +1,22 @@
+import { describe, it, expect } from "vitest";
+import { available } from "./harness.js";
+import { slack } from "../../skills/slack.js";
+const ctx = () => ({
+    config: {
+        SLACK_WEBHOOK_URL: process.env.SLACK_WEBHOOK_URL ?? "",
+        SLACK_BOT_TOKEN: process.env.SLACK_BOT_TOKEN ?? "",
+    },
+    logger: console,
+});
+// Only run Slack integration tests when explicitly opted in
+// to avoid spamming channels during routine test runs
+const slackEnabled = available.slack && process.env.SLACK_INTEGRATION_TEST === "1";
+describe.runIf(slackEnabled)("slack integration", () => {
+    it("sends a test message via webhook", async () => {
+        if (!process.env.SLACK_WEBHOOK_URL)
+            return;
+        const tool = slack.tools.find((t) => t.name === "slack_send_message");
+        const result = await tool.handler({ text: `🧪 SWEny integration test — ${new Date().toISOString()}` }, ctx());
+        expect(result).toHaveProperty("ok");
+    }, 15_000);
+});

package/dist/__tests__/schema.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/schema.test.js

@@ -0,0 +1,239 @@
+import { describe, it, expect } from "vitest";
+import { workflowZ, nodeZ, edgeZ, skillZ, toolZ, parseWorkflow, validateWorkflow, workflowJsonSchema, } from "../schema.js";
+import { triageWorkflow } from "../workflows/triage.js";
+import { implementWorkflow } from "../workflows/implement.js";
+// ─── Test fixtures ───────────────────────────────────────────────
+const validWorkflow = {
+    id: "test-wf",
+    name: "Test Workflow",
+    description: "A→B→C",
+    entry: "a",
+    nodes: {
+        a: { name: "A", instruction: "Do A", skills: ["github"] },
+        b: { name: "B", instruction: "Do B", skills: [] },
+        c: { name: "C", instruction: "Do C", skills: [] },
+    },
+    edges: [
+        { from: "a", to: "b" },
+        { from: "b", to: "c" },
+    ],
+};
+// ─── Zod schema tests ────────────────────────────────────────────
+describe("Zod schemas", () => {
+    describe("nodeZ", () => {
+        it("parses a valid node", () => {
+            const result = nodeZ.parse({ name: "Step", instruction: "Do it", skills: ["github"] });
+            expect(result.name).toBe("Step");
+            expect(result.skills).toEqual(["github"]);
+        });
+        it("defaults skills to empty array", () => {
+            const result = nodeZ.parse({ name: "Step", instruction: "Do it" });
+            expect(result.skills).toEqual([]);
+        });
+        it("rejects empty name", () => {
+            expect(() => nodeZ.parse({ name: "", instruction: "x" })).toThrow();
+        });
+        it("rejects empty instruction", () => {
+            expect(() => nodeZ.parse({ name: "x", instruction: "" })).toThrow();
+        });
+        it("accepts optional output schema", () => {
+            const result = nodeZ.parse({
+                name: "S",
+                instruction: "I",
+                output: { type: "object", properties: { severity: { type: "string" } } },
+            });
+            expect(result.output).toBeDefined();
+        });
+    });
+    describe("edgeZ", () => {
+        it("parses a simple edge", () => {
+            const result = edgeZ.parse({ from: "a", to: "b" });
+            expect(result.from).toBe("a");
+            expect(result.when).toBeUndefined();
+        });
+        it("parses an edge with condition", () => {
+            const result = edgeZ.parse({ from: "a", to: "b", when: "severity is high" });
+            expect(result.when).toBe("severity is high");
+        });
+        it("rejects empty from", () => {
+            expect(() => edgeZ.parse({ from: "", to: "b" })).toThrow();
+        });
+        it("rejects empty to", () => {
+            expect(() => edgeZ.parse({ from: "a", to: "" })).toThrow();
+        });
+    });
+    describe("toolZ", () => {
+        it("parses a valid tool", () => {
+            const result = toolZ.parse({
+                name: "my_tool",
+                description: "Does things",
+                input_schema: { type: "object", properties: {} },
+            });
+            expect(result.name).toBe("my_tool");
+        });
+        it("rejects empty name", () => {
+            expect(() => toolZ.parse({ name: "", description: "x", input_schema: {} })).toThrow();
+        });
+    });
+    describe("skillZ", () => {
+        it("parses a valid skill", () => {
+            const result = skillZ.parse({
+                id: "test",
+                name: "Test",
+                description: "A test skill",
+                category: "general",
+                config: {
+                    TOKEN: { description: "API token", required: true, env: "TOKEN" },
+                },
+                tools: [{ name: "t", description: "d", input_schema: {} }],
+            });
+            expect(result.id).toBe("test");
+            expect(result.tools).toHaveLength(1);
+        });
+    });
+    describe("workflowZ", () => {
+        it("parses a valid workflow", () => {
+            const raw = JSON.parse(JSON.stringify(validWorkflow));
+            const result = workflowZ.parse(raw);
+            expect(result.id).toBe("test-wf");
+            expect(Object.keys(result.nodes)).toHaveLength(3);
+        });
+        it("defaults description to empty string", () => {
+            const raw = {
+                id: "x",
+                name: "X",
+                entry: "a",
+                nodes: { a: { name: "A", instruction: "Do A" } },
+                edges: [],
+            };
+            const result = workflowZ.parse(raw);
+            expect(result.description).toBe("");
+        });
+        it("rejects missing id", () => {
+            expect(() => workflowZ.parse({ name: "x", entry: "a", nodes: {}, edges: [] })).toThrow();
+        });
+        it("rejects missing entry", () => {
+            expect(() => workflowZ.parse({ id: "x", name: "x", nodes: {}, edges: [] })).toThrow();
+        });
+        it("rejects empty id", () => {
+            expect(() => workflowZ.parse({ id: "", name: "x", entry: "a", nodes: {}, edges: [] })).toThrow();
+        });
+    });
+    describe("parseWorkflow", () => {
+        it("parses a raw JSON workflow", () => {
+            const raw = JSON.parse(JSON.stringify(validWorkflow));
+            const parsed = parseWorkflow(raw);
+            expect(parsed.id).toBe("test-wf");
+            expect(parsed.nodes["a"].instruction).toBe("Do A");
+        });
+        it("rejects invalid input", () => {
+            expect(() => parseWorkflow({ id: "" })).toThrow();
+            expect(() => parseWorkflow(null)).toThrow();
+            expect(() => parseWorkflow("not an object")).toThrow();
+        });
+    });
+});
+// ─── Structural validation tests ─────────────────────────────────
+describe("validateWorkflow", () => {
+    it("validates a correct workflow", () => {
+        expect(validateWorkflow(validWorkflow)).toEqual([]);
+    });
+    it("detects missing entry node", () => {
+        const bad = { ...validWorkflow, entry: "nonexistent" };
+        const errors = validateWorkflow(bad);
+        expect(errors).toContainEqual(expect.objectContaining({ code: "MISSING_ENTRY" }));
+    });
+    it("detects unknown edge source", () => {
+        const bad = {
+            ...validWorkflow,
+            edges: [{ from: "ghost", to: "b" }],
+        };
+        const errors = validateWorkflow(bad);
+        expect(errors).toContainEqual(expect.objectContaining({ code: "UNKNOWN_EDGE_SOURCE" }));
+    });
+    it("detects unknown edge target", () => {
+        const bad = {
+            ...validWorkflow,
+            edges: [{ from: "a", to: "ghost" }],
+        };
+        const errors = validateWorkflow(bad);
+        expect(errors).toContainEqual(expect.objectContaining({ code: "UNKNOWN_EDGE_TARGET" }));
+    });
+    it("detects self-loops", () => {
+        const loopy = {
+            ...validWorkflow,
+            edges: [
+                { from: "a", to: "a" },
+                { from: "a", to: "b" },
+                { from: "b", to: "c" },
+            ],
+        };
+        const errors = validateWorkflow(loopy);
+        expect(errors).toContainEqual(expect.objectContaining({ code: "SELF_LOOP", nodeId: "a" }));
+    });
+    it("detects unreachable nodes", () => {
+        const disconnected = {
+            ...validWorkflow,
+            edges: [{ from: "a", to: "b" }],
+            // c has no incoming edge from the reachable set
+        };
+        const errors = validateWorkflow(disconnected);
+        expect(errors).toContainEqual(expect.objectContaining({ code: "UNREACHABLE_NODE", nodeId: "c" }));
+    });
+    it("detects unknown skill references", () => {
+        const errors = validateWorkflow(validWorkflow, new Set(["not-github"]));
+        expect(errors).toContainEqual(expect.objectContaining({ code: "UNKNOWN_SKILL", nodeId: "a" }));
+    });
+    it("passes when known skills match", () => {
+        const errors = validateWorkflow(validWorkflow, new Set(["github"]));
+        expect(errors).toEqual([]);
+    });
+    it("validates triage workflow", () => {
+        expect(validateWorkflow(triageWorkflow)).toEqual([]);
+    });
+    it("validates implement workflow", () => {
+        expect(validateWorkflow(implementWorkflow)).toEqual([]);
+    });
+    it("handles empty nodes object", () => {
+        const empty = {
+            id: "empty",
+            name: "Empty",
+            description: "",
+            entry: "x",
+            nodes: {},
+            edges: [],
+        };
+        const errors = validateWorkflow(empty);
+        expect(errors).toContainEqual(expect.objectContaining({ code: "MISSING_ENTRY" }));
+    });
+});
+// ─── JSON Schema shape tests ─────────────────────────────────────
+describe("workflowJsonSchema", () => {
+    it("has the correct $id", () => {
+        expect(workflowJsonSchema.$id).toBe("https://sweny.ai/schemas/workflow.json");
+    });
+    it("requires all top-level fields", () => {
+        expect(workflowJsonSchema.required).toContain("id");
+        expect(workflowJsonSchema.required).toContain("name");
+        expect(workflowJsonSchema.required).toContain("nodes");
+        expect(workflowJsonSchema.required).toContain("edges");
+        expect(workflowJsonSchema.required).toContain("entry");
+    });
+    it("has additionalProperties: false at top level", () => {
+        expect(workflowJsonSchema.additionalProperties).toBe(false);
+    });
+    it("has additionalProperties: false on edge items", () => {
+        expect(workflowJsonSchema.properties.edges.items.additionalProperties).toBe(false);
+    });
+    it("has additionalProperties: false on node items", () => {
+        expect(workflowJsonSchema.properties.nodes.additionalProperties.additionalProperties).toBe(false);
+    });
+    it("edge items require from and to", () => {
+        expect(workflowJsonSchema.properties.edges.items.required).toContain("from");
+        expect(workflowJsonSchema.properties.edges.items.required).toContain("to");
+    });
+    it("node items require name and instruction", () => {
+        expect(workflowJsonSchema.properties.nodes.additionalProperties.required).toContain("name");
+        expect(workflowJsonSchema.properties.nodes.additionalProperties.required).toContain("instruction");
+    });
+});

package/dist/__tests__/skills-index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/skills-index.test.js

@@ -0,0 +1,122 @@
+import { describe, it, expect } from "vitest";
+import { github, linear, slack, sentry, datadog, betterstack, notification, builtinSkills, createSkillMap, allSkills, isSkillConfigured, validateWorkflowSkills, } from "../skills/index.js";
+describe("skills registry", () => {
+    it("exports all builtin skills", () => {
+        expect(builtinSkills.length).toBeGreaterThanOrEqual(7);
+        const ids = builtinSkills.map((s) => s.id);
+        expect(ids).toContain("github");
+        expect(ids).toContain("linear");
+        expect(ids).toContain("slack");
+        expect(ids).toContain("sentry");
+        expect(ids).toContain("datadog");
+        expect(ids).toContain("betterstack");
+        expect(ids).toContain("notification");
+    });
+    it("individual skill exports match builtins", () => {
+        expect(builtinSkills).toContain(github);
+        expect(builtinSkills).toContain(linear);
+        expect(builtinSkills).toContain(slack);
+        expect(builtinSkills).toContain(sentry);
+        expect(builtinSkills).toContain(datadog);
+        expect(builtinSkills).toContain(betterstack);
+        expect(builtinSkills).toContain(notification);
+    });
+    it("createSkillMap builds a correct map", () => {
+        const map = createSkillMap([github, slack]);
+        expect(map.size).toBe(2);
+        expect(map.get("github")).toBe(github);
+        expect(map.get("slack")).toBe(slack);
+    });
+    it("createSkillMap throws on duplicate IDs", () => {
+        expect(() => createSkillMap([github, github])).toThrow("Duplicate skill ID");
+    });
+    it("allSkills returns all builtin skills as a map", () => {
+        const map = allSkills();
+        expect(map.size).toBe(builtinSkills.length);
+        for (const skill of builtinSkills) {
+            expect(map.has(skill.id)).toBe(true);
+        }
+    });
+    it("no tool name collisions across skills", () => {
+        const seen = new Set();
+        for (const skill of builtinSkills) {
+            for (const tool of skill.tools) {
+                expect(seen.has(tool.name)).toBe(false);
+                seen.add(tool.name);
+            }
+        }
+    });
+    it("all tools have name, description, and input_schema", () => {
+        for (const skill of builtinSkills) {
+            for (const tool of skill.tools) {
+                expect(tool.name).toBeTruthy();
+                expect(tool.description).toBeTruthy();
+                expect(tool.input_schema).toBeDefined();
+                expect(typeof tool.handler).toBe("function");
+            }
+        }
+    });
+    it("all skills have valid metadata and category", () => {
+        const validCategories = ["git", "observability", "tasks", "notification", "general"];
+        for (const skill of builtinSkills) {
+            expect(skill.id).toBeTruthy();
+            expect(skill.name).toBeTruthy();
+            expect(skill.description).toBeTruthy();
+            expect(skill.config).toBeDefined();
+            expect(Array.isArray(skill.tools)).toBe(true);
+            expect(validCategories).toContain(skill.category);
+        }
+    });
+    it("isSkillConfigured checks env vars", () => {
+        expect(isSkillConfigured(github, { GITHUB_TOKEN: "ghp_xxx" })).toBe(true);
+        expect(isSkillConfigured(github, {})).toBe(false);
+        // Slack has all-optional config — needs at least one to be usable
+        expect(isSkillConfigured(slack, {})).toBe(false);
+        expect(isSkillConfigured(slack, { SLACK_WEBHOOK_URL: "https://hooks.slack.com/..." })).toBe(true);
+        expect(isSkillConfigured(slack, { SLACK_BOT_TOKEN: "xoxb-..." })).toBe(true);
+    });
+    it("validateWorkflowSkills detects missing providers", () => {
+        const workflow = {
+            nodes: {
+                gather: { skills: ["github", "sentry", "betterstack"] },
+                notify: { skills: ["slack"] },
+            },
+        };
+        // Only github is available
+        const available = createSkillMap([github]);
+        const result = validateWorkflowSkills(workflow, available);
+        expect(result.configured).toHaveLength(1);
+        expect(result.configured[0].id).toBe("github");
+        expect(result.missing.some((m) => m.id === "sentry")).toBe(true);
+        expect(result.missing.some((m) => m.id === "betterstack")).toBe(true);
+        // gather node has github (git) but no observability → error
+        expect(result.errors.length).toBeGreaterThan(0);
+        // notify node has no notification → warning (not error)
+        expect(result.warnings.length).toBeGreaterThan(0);
+    });
+    it("validateWorkflowSkills passes when all categories covered", () => {
+        const workflow = {
+            nodes: {
+                gather: { skills: ["github", "sentry"] },
+            },
+        };
+        const available = createSkillMap([github, sentry]);
+        const result = validateWorkflowSkills(workflow, available);
+        expect(result.errors).toHaveLength(0);
+        expect(result.warnings).toHaveLength(0);
+        expect(result.configured).toHaveLength(2);
+    });
+    it("config fields have env vars matching canonical names", () => {
+        // Datadog should use DD_* prefix
+        for (const [key, field] of Object.entries(datadog.config)) {
+            if (field.env) {
+                expect(field.env).toMatch(/^DD_/);
+            }
+        }
+        // Sentry base URL should be SENTRY_BASE_URL not SENTRY_URL
+        const sentryConfig = Object.values(sentry.config).find((f) => f.env?.includes("SENTRY") && f.env?.includes("URL"));
+        if (sentryConfig) {
+            expect(sentryConfig.env).toBe("SENTRY_BASE_URL");
+        }
+    });
+});

package/dist/__tests__/skills.test.d.ts

@@ -0,0 +1 @@
+export {};