@sweny-ai/core 0.1.37 → 0.1.39

package/dist/__tests__/claude.test.js

@@ -250,6 +250,105 @@ describe("ClaudeClient", () => {
         expect(result.status).toBe("failed");
         expect(result.data.error).toContain("Too many turns");
     });
+    // terminal_reason was added in @anthropic-ai/claude-agent-sdk v0.2.91.
+    // When the turn budget is exhausted the SDK now emits subtype='success'
+    // alongside terminal_reason='max_turns' instead of the old error subtype,
+    // so the claude.ts handler has to look at both fields or silently accept
+    // truncated output as a success.
+    describe("terminal_reason handling (claude-agent-sdk v0.2.91+)", () => {
+        it("returns failed when terminal_reason is max_turns", async () => {
+            mockQuery.mockReturnValueOnce(makeStream([
+                {
+                    type: "result",
+                    subtype: "success",
+                    result: "partial output",
+                    terminal_reason: "max_turns",
+                },
+            ]));
+            const client = new ClaudeClient();
+            const result = await client.run({ instruction: "x", context: {}, tools: [] });
+            expect(result.status).toBe("failed");
+            expect(result.data.error).toContain("max_turns");
+            expect(result.data.error).toContain("terminated early");
+        });
+        it("returns failed for any non-completed terminal_reason", async () => {
+            // Future SDK versions may add new terminal reasons (aborted_tools,
+            // blocking_limit, etc.) — treat anything that isn't 'completed' as a
+            // failure rather than assume it's recoverable.
+            mockQuery.mockReturnValueOnce(makeStream([
+                {
+                    type: "result",
+                    subtype: "success",
+                    result: "partial",
+                    terminal_reason: "aborted_tools",
+                },
+            ]));
+            const client = new ClaudeClient();
+            const result = await client.run({ instruction: "x", context: {}, tools: [] });
+            expect(result.status).toBe("failed");
+            expect(result.data.error).toContain("aborted_tools");
+        });
+        it("returns success when terminal_reason is 'completed'", async () => {
+            mockQuery.mockReturnValueOnce(makeStream([
+                {
+                    type: "result",
+                    subtype: "success",
+                    result: '{"ok": true}',
+                    terminal_reason: "completed",
+                },
+            ]));
+            const client = new ClaudeClient();
+            const result = await client.run({ instruction: "x", context: {}, tools: [] });
+            expect(result.status).toBe("success");
+            expect(result.data.ok).toBe(true);
+        });
+        it("returns success when terminal_reason is absent (pre-v0.2.91 SDK)", async () => {
+            // Old SDKs never set terminal_reason. The guard must not treat an
+            // absent field as a failure or every caller would break on downgrade.
+            mockQuery.mockReturnValueOnce(makeStream([
+                {
+                    type: "result",
+                    subtype: "success",
+                    result: '{"done": true}',
+                    // terminal_reason deliberately omitted
+                },
+            ]));
+            const client = new ClaudeClient();
+            const result = await client.run({ instruction: "x", context: {}, tools: [] });
+            expect(result.status).toBe("success");
+            expect(result.data.done).toBe(true);
+        });
+        it("preserves toolCalls when failing on terminal_reason", async () => {
+            // A max_turns failure should still surface any tool calls that
+            // happened before the budget ran out, so debuggers can see what
+            // Claude was trying to do.
+            mockQuery.mockReturnValueOnce(makeStream([
+                {
+                    type: "assistant",
+                    message: {
+                        content: [
+                            {
+                                type: "tool_use",
+                                name: "search_code",
+                                input: { query: "foo" },
+                            },
+                        ],
+                    },
+                },
+                {
+                    type: "result",
+                    subtype: "success",
+                    result: "partial",
+                    terminal_reason: "max_turns",
+                },
+            ]));
+            const client = new ClaudeClient();
+            const result = await client.run({ instruction: "x", context: {}, tools: [] });
+            expect(result.status).toBe("failed");
+            expect(result.toolCalls).toHaveLength(1);
+            expect(result.toolCalls[0].tool).toBe("search_code");
+        });
+    });
     it("passes model option to query", async () => {
         mockQuery.mockReturnValueOnce(makeStream([{ type: "result", subtype: "success", result: "ok" }]));
         const client = new ClaudeClient({ model: "claude-sonnet-4-20250514" });

package/dist/__tests__/skills.test.js

@@ -8,7 +8,8 @@ import { slack } from "../skills/slack.js";
 import { sentry } from "../skills/sentry.js";
 import { datadog } from "../skills/datadog.js";
 import { notification } from "../skills/notification.js";
-import { loadCustomSkills, configuredSkills, createSkillMap } from "../skills/index.js";
+import { createSkillMap } from "../skills/index.js";
+import { loadCustomSkills, configuredSkills } from "../skills/custom-loader.js";
 // ─── Helpers ─────────────────────────────────────────────────────
 const mockCtx = (config = {}) => ({
     config,

package/dist/browser.d.ts

@@ -9,7 +9,7 @@ export type { Skill, SkillCategory, Tool, ToolContext, ConfigField, JSONSchema,
 export { consoleLogger } from "./types.js";
 export { execute } from "./executor.js";
 export type { ExecuteOptions } from "./executor.js";
-export { github, linear, slack, sentry, datadog, notification, builtinSkills, createSkillMap, allSkills, isSkillConfigured, configuredSkills, validateWorkflowSkills, } from "./skills/index.js";
+export { github, linear, slack, sentry, datadog, notification, builtinSkills, createSkillMap, allSkills, isSkillConfigured, configuredBuiltinSkills, validateWorkflowSkills, } from "./skills/index.js";
 export type { SkillValidationResult } from "./skills/index.js";
 export { workflowZ, nodeZ, edgeZ, skillZ, parseWorkflow, validateWorkflow, workflowJsonSchema } from "./schema.js";
 export type { WorkflowError } from "./schema.js";

package/dist/browser.js

@@ -8,8 +8,8 @@
 export { consoleLogger } from "./types.js";
 // Executor
 export { execute } from "./executor.js";
-// Skills
-export { github, linear, slack, sentry, datadog, notification, builtinSkills, createSkillMap, allSkills, isSkillConfigured, configuredSkills, validateWorkflowSkills, } from "./skills/index.js";
+// Skills (browser-safe — no filesystem access, no `process.env` reads)
+export { github, linear, slack, sentry, datadog, notification, builtinSkills, createSkillMap, allSkills, isSkillConfigured, configuredBuiltinSkills, validateWorkflowSkills, } from "./skills/index.js";
 // Schema & validation
 export { workflowZ, nodeZ, edgeZ, skillZ, parseWorkflow, validateWorkflow, workflowJsonSchema } from "./schema.js";
 // Studio adapter

package/dist/claude.js

@@ -112,6 +112,19 @@ export class ClaudeClient {
                 else if (message.type === "result") {
                     const resultMsg = message;
                     if (resultMsg.subtype === "success" && "result" in resultMsg) {
+                        // terminal_reason was added in @anthropic-ai/claude-agent-sdk v0.2.91.
+                        // When the turn budget is exhausted the SDK still emits subtype='success'
+                        // but sets terminal_reason='max_turns'. Treat anything other than
+                        // 'completed' (or absent) as a failure so callers are not silently fed
+                        // incomplete output.
+                        const terminalReason = resultMsg.terminal_reason;
+                        if (terminalReason && terminalReason !== "completed") {
+                            return {
+                                status: "failed",
+                                data: { error: `Claude query terminated early: ${terminalReason}` },
+                                toolCalls,
+                            };
+                        }
                         response = resultMsg.result;
                     }
                     else if ("errors" in resultMsg) {

package/dist/cli/e2e.js

@@ -11,7 +11,8 @@ import chalk from "chalk";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 import { execute } from "../executor.js";
 import { ClaudeClient } from "../claude.js";
-import { createSkillMap, configuredSkills } from "../skills/index.js";
+import { createSkillMap } from "../skills/index.js";
+import { configuredSkills } from "../skills/custom-loader.js";
 import { consoleLogger } from "../types.js";
 import { validateWorkflow } from "../schema.js";
 // ── Template variable resolution ───────────────────────────────────────

package/dist/cli/main.js

@@ -10,7 +10,8 @@ import { execute } from "../executor.js";
 import { triageWorkflow, implementWorkflow, seedContentWorkflow } from "../workflows/index.js";
 import { consoleLogger } from "../types.js";
 import { ClaudeClient } from "../claude.js";
-import { createSkillMap, configuredSkills } from "../skills/index.js";
+import { createSkillMap } from "../skills/index.js";
+import { configuredSkills } from "../skills/custom-loader.js";
 import { buildAutoMcpServers, buildProviderContext } from "../mcp.js";
 import { loadAdditionalContext } from "../templates.js";
 import { validateWorkflow as validateWorkflowSchema } from "../schema.js";

package/dist/index.d.ts

@@ -27,8 +27,9 @@ export { execute } from "./executor.js";
 export type { ExecuteOptions } from "./executor.js";
 export { ClaudeClient } from "./claude.js";
 export type { ClaudeClientOptions } from "./claude.js";
-export { github, linear, slack, sentry, datadog, notification, supabase, builtinSkills, createSkillMap, allSkills, isSkillConfigured, configuredSkills, validateWorkflowSkills, } from "./skills/index.js";
+export { github, linear, slack, sentry, datadog, notification, supabase, builtinSkills, createSkillMap, allSkills, isSkillConfigured, configuredBuiltinSkills, validateWorkflowSkills, } from "./skills/index.js";
 export type { SkillValidationResult } from "./skills/index.js";
+export { loadCustomSkills, configuredSkills } from "./skills/custom-loader.js";
 export { workflowZ, nodeZ, edgeZ, skillZ, parseWorkflow, validateWorkflow, workflowJsonSchema } from "./schema.js";
 export type { WorkflowError } from "./schema.js";
 export { buildAutoMcpServers, buildProviderContext } from "./mcp.js";

package/dist/index.js

@@ -27,7 +27,9 @@ export { execute } from "./executor.js";
 // Claude client
 export { ClaudeClient } from "./claude.js";
 // Skills
-export { github, linear, slack, sentry, datadog, notification, supabase, builtinSkills, createSkillMap, allSkills, isSkillConfigured, configuredSkills, validateWorkflowSkills, } from "./skills/index.js";
+export { github, linear, slack, sentry, datadog, notification, supabase, builtinSkills, createSkillMap, allSkills, isSkillConfigured, configuredBuiltinSkills, validateWorkflowSkills, } from "./skills/index.js";
+// Node-only skill discovery (filesystem-based)
+export { loadCustomSkills, configuredSkills } from "./skills/custom-loader.js";
 // Schema & validation
 export { workflowZ, nodeZ, edgeZ, skillZ, parseWorkflow, validateWorkflow, workflowJsonSchema } from "./schema.js";
 // MCP auto-injection

package/dist/skills/custom-loader.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Custom skill discovery — Node-only.
+ *
+ * Lives outside `skills/index.ts` so the registry stays browser-safe. Anything
+ * that needs `node:fs` / `node:path` / `process.cwd()` belongs here.
+ */
+import type { Skill } from "../types.js";
+/**
+ * Load custom skills from a `.claude/skills/` directory.
+ *
+ * Custom skills are instruction-only (no tools or config) — they provide
+ * guidance documents that the coding agent reads from the filesystem.
+ * Registering them here ensures workflow validation recognises the skill IDs
+ * so nodes referencing them don't produce spurious warnings.
+ */
+export declare function loadCustomSkills(cwd?: string): Skill[];
+/**
+ * From all builtins + custom repo skills, return only the skills that are usable.
+ * Built-in skills are filtered by env vars; custom skills are always included.
+ *
+ * Node-only: reads `.claude/skills/` from disk. Browser code should call
+ * `configuredBuiltinSkills` from `@sweny-ai/core/browser` instead.
+ */
+export declare function configuredSkills(env?: Record<string, string | undefined>, cwd?: string): Skill[];

package/dist/skills/custom-loader.js

@@ -0,0 +1,88 @@
+/**
+ * Custom skill discovery — Node-only.
+ *
+ * Lives outside `skills/index.ts` so the registry stays browser-safe. Anything
+ * that needs `node:fs` / `node:path` / `process.cwd()` belongs here.
+ */
+import { readdirSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import YAML from "yaml";
+import { builtinSkills, isSkillConfigured } from "./index.js";
+/**
+ * Load custom skills from a `.claude/skills/` directory.
+ *
+ * Custom skills are instruction-only (no tools or config) — they provide
+ * guidance documents that the coding agent reads from the filesystem.
+ * Registering them here ensures workflow validation recognises the skill IDs
+ * so nodes referencing them don't produce spurious warnings.
+ */
+export function loadCustomSkills(cwd = process.cwd()) {
+    const skillsDir = join(cwd, ".claude", "skills");
+    if (!existsSync(skillsDir))
+        return [];
+    const skills = [];
+    let entries;
+    try {
+        entries = readdirSync(skillsDir, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => d.name);
+    }
+    catch {
+        return [];
+    }
+    for (const dirName of entries) {
+        const skillFile = join(skillsDir, dirName, "SKILL.md");
+        if (!existsSync(skillFile))
+            continue;
+        try {
+            const content = readFileSync(skillFile, "utf-8");
+            const frontmatter = parseFrontmatter(content);
+            if (!frontmatter?.name)
+                continue;
+            skills.push({
+                id: frontmatter.name,
+                name: frontmatter.name,
+                description: frontmatter.description ?? `Custom skill: ${frontmatter.name}`,
+                category: "general",
+                config: {},
+                tools: [],
+            });
+        }
+        catch {
+            // Skip malformed skill files
+        }
+    }
+    return skills;
+}
+/** Extract YAML frontmatter from a markdown file (between --- delimiters). */
+function parseFrontmatter(content) {
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!match)
+        return null;
+    try {
+        return YAML.parse(match[1]);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * From all builtins + custom repo skills, return only the skills that are usable.
+ * Built-in skills are filtered by env vars; custom skills are always included.
+ *
+ * Node-only: reads `.claude/skills/` from disk. Browser code should call
+ * `configuredBuiltinSkills` from `@sweny-ai/core/browser` instead.
+ */
+export function configuredSkills(env = process.env, cwd) {
+    const configured = builtinSkills.filter((s) => isSkillConfigured(s, env));
+    const custom = loadCustomSkills(cwd);
+    // Deduplicate: built-in skills take precedence over custom skills with the same ID
+    const ids = new Set(configured.map((s) => s.id));
+    for (const skill of custom) {
+        if (!ids.has(skill.id)) {
+            configured.push(skill);
+            ids.add(skill.id);
+        }
+    }
+    return configured;
+}

package/dist/skills/index.d.ts

@@ -2,6 +2,10 @@
  * Skill Registry
  *
  * All built-in skills + helpers to build a skill map from config.
+ *
+ * This module is browser-safe — no `node:fs`, no `node:path`, no `process`.
+ * 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 { github } from "./github.js";
@@ -14,15 +18,6 @@ import { notification } from "./notification.js";
 import { supabase } from "./supabase.js";
 export declare const builtinSkills: Skill[];
 export { github, linear, slack, sentry, datadog, betterstack, notification, supabase };
-/**
- * Load custom skills from a `.claude/skills/` directory.
- *
- * Custom skills are instruction-only (no tools or config) — they provide
- * guidance documents that the coding agent reads from the filesystem.
- * Registering them here ensures workflow validation recognises the skill IDs
- * so nodes referencing them don't produce spurious warnings.
- */
-export declare function loadCustomSkills(cwd?: string): Skill[];
 /**
  * Build a skill map from an array of skills.
  * Pass to `execute()` as the `skills` option.
@@ -47,10 +42,13 @@ export declare function allSkills(): Map<string, Skill>;
  */
 export declare function isSkillConfigured(skill: Skill, env?: Record<string, string | undefined>): boolean;
 /**
- * From all builtins + custom repo skills, return only the skills that are usable.
- * Built-in skills are filtered by env vars; custom skills are always included.
+ * Browser-safe variant of `configuredSkills`: returns only the *built-in* skills
+ * whose required env vars are present. Does not touch the filesystem.
+ *
+ * Node callers should use `configuredSkills` from `@sweny-ai/core`, which also
+ * loads custom skills from `.claude/skills/`.
  */
-export declare function configuredSkills(env?: Record<string, string | undefined>, cwd?: string): Skill[];
+export declare function configuredBuiltinSkills(env?: Record<string, string | undefined>): Skill[];
 /**
  * Validate that a workflow's skill requirements are satisfiable.
  *

package/dist/skills/index.js

@@ -2,10 +2,11 @@
  * Skill Registry
  *
  * All built-in skills + helpers to build a skill map from config.
+ *
+ * This module is browser-safe — no `node:fs`, no `node:path`, no `process`.
+ * 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 { readdirSync, readFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import YAML from "yaml";
 import { github } from "./github.js";
 import { linear } from "./linear.js";
 import { slack } from "./slack.js";
@@ -17,65 +18,6 @@ import { supabase } from "./supabase.js";
 // ─── Built-in skill catalog ─────────────────────────────────────
 export const builtinSkills = [github, linear, slack, sentry, datadog, betterstack, notification, supabase];
 export { github, linear, slack, sentry, datadog, betterstack, notification, supabase };
-// ─── Custom skill discovery ─────────────────────────────────────
-/**
- * Load custom skills from a `.claude/skills/` directory.
- *
- * Custom skills are instruction-only (no tools or config) — they provide
- * guidance documents that the coding agent reads from the filesystem.
- * Registering them here ensures workflow validation recognises the skill IDs
- * so nodes referencing them don't produce spurious warnings.
- */
-export function loadCustomSkills(cwd = process.cwd()) {
-    const skillsDir = join(cwd, ".claude", "skills");
-    if (!existsSync(skillsDir))
-        return [];
-    const skills = [];
-    let entries;
-    try {
-        entries = readdirSync(skillsDir, { withFileTypes: true })
-            .filter((d) => d.isDirectory())
-            .map((d) => d.name);
-    }
-    catch {
-        return [];
-    }
-    for (const dirName of entries) {
-        const skillFile = join(skillsDir, dirName, "SKILL.md");
-        if (!existsSync(skillFile))
-            continue;
-        try {
-            const content = readFileSync(skillFile, "utf-8");
-            const frontmatter = parseFrontmatter(content);
-            if (!frontmatter?.name)
-                continue;
-            skills.push({
-                id: frontmatter.name,
-                name: frontmatter.name,
-                description: frontmatter.description ?? `Custom skill: ${frontmatter.name}`,
-                category: "general",
-                config: {},
-                tools: [],
-            });
-        }
-        catch {
-            // Skip malformed skill files
-        }
-    }
-    return skills;
-}
-/** Extract YAML frontmatter from a markdown file (between --- delimiters). */
-function parseFrontmatter(content) {
-    const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
-    if (!match)
-        return null;
-    try {
-        return YAML.parse(match[1]);
-    }
-    catch {
-        return null;
-    }
-}
 // ─── Registry helpers ───────────────────────────────────────────
 /**
  * Build a skill map from an array of skills.
@@ -110,7 +52,7 @@ export function allSkills() {
  * Optional fields are validated by individual tool handlers at call time,
  * so missing optional config never disqualifies the skill.
  */
-export function isSkillConfigured(skill, env = process.env) {
+export function isSkillConfigured(skill, env = {}) {
     for (const field of Object.values(skill.config)) {
         if (field.required && field.env && !env[field.env])
             return false;
@@ -118,21 +60,14 @@ export function isSkillConfigured(skill, env = process.env) {
     return true;
 }
 /**
- * From all builtins + custom repo skills, return only the skills that are usable.
- * Built-in skills are filtered by env vars; custom skills are always included.
+ * Browser-safe variant of `configuredSkills`: returns only the *built-in* skills
+ * whose required env vars are present. Does not touch the filesystem.
+ *
+ * Node callers should use `configuredSkills` from `@sweny-ai/core`, which also
+ * loads custom skills from `.claude/skills/`.
  */
-export function configuredSkills(env = process.env, cwd) {
-    const configured = builtinSkills.filter((s) => isSkillConfigured(s, env));
-    const custom = loadCustomSkills(cwd);
-    // Deduplicate: built-in skills take precedence over custom skills with the same ID
-    const ids = new Set(configured.map((s) => s.id));
-    for (const skill of custom) {
-        if (!ids.has(skill.id)) {
-            configured.push(skill);
-            ids.add(skill.id);
-        }
-    }
-    return configured;
+export function configuredBuiltinSkills(env = {}) {
+    return builtinSkills.filter((s) => isSkillConfigured(s, env));
 }
 export function validateWorkflowSkills(workflow, available) {
     const configured = [];

package/package.json

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