@sweny-ai/core 0.1.106 → 0.1.108

package/dist/executor.js

@@ -742,6 +742,23 @@ async function resolveNext(workflow, current, results, input, claude, observer,
     // Check for a default (unconditional) edge among conditionals
     const defaultEdge = outEdges.find((e) => !e.when);
     const conditionalEdges = outEdges.filter((e) => e.when);
+    // Defense-in-depth for AMBIGUOUS_EDGES (rejected by validateWorkflow): with
+    // no conditional edges there is nothing for the route evaluator to decide.
+    // Follow the (first) unconditional edge directly and skip the no-op
+    // claude.evaluate call. validateWorkflow already rejects 2+ unconditional
+    // edges, so a well-formed workflow reaching here has exactly one default.
+    if (conditionalEdges.length === 0 && defaultEdge) {
+        if (outEdges.length > 1) {
+            logger?.warn(`  route eval: node '${current}' has ${outEdges.length} unconditional out-edges; following '${defaultEdge.to}' ` +
+                `and ignoring the rest. Add 'when' clauses to make routing deterministic (see AMBIGUOUS_EDGES).`, { node: current });
+        }
+        if (edgeCounts) {
+            const key = `${current}→${defaultEdge.to}`;
+            edgeCounts.set(key, (edgeCounts.get(key) ?? 0) + 1);
+        }
+        safeObserve(observer, { type: "route", from: current, to: defaultEdge.to, reason: "only path" }, logger);
+        return defaultEdge.to;
+    }
     // Claude evaluates which condition matches. Include input so conditions
     // can reference workflow-level flags like dryRun, and expose evals so
     // routing edges can read `priorNode.evals.X.pass`.
@@ -756,7 +773,14 @@ async function resolveNext(workflow, current, results, input, claude, observer,
     for (const [k, v] of results.entries()) {
         const { view, missing } = buildRouteEvalEntry(v, workflow.nodes[k]);
         context[k] = view;
-        if (missing.length > 0) {
+        // Only a successful node has an output contract to violate. A node that
+        // was skipped (requires not met) or failed before producing output never
+        // emitted its declared properties; its data is { skipped_reason } / { error }.
+        // Warning that those nodes are "missing declared properties" is misleading
+        // noise — it alarms operators and pollutes telemetry on every skip. Still
+        // build the view above so routing can read the skipped/failed data; only
+        // suppress the warning + node:warning for non-success nodes.
+        if (missing.length > 0 && v.status === "success") {
             // Loud signal for the operator. The view itself already replaces the
             // missing keys with explicit `null`, so the LLM evaluator cannot
             // ghost-match "is N" or "is undefined" against a structurally-absent

package/dist/mcp-catalog.js

@@ -47,7 +47,10 @@ const gitlab = {
         if (!creds.GITLAB_TOKEN)
             return undefined;
         const env = { GITLAB_PERSONAL_ACCESS_TOKEN: creds.GITLAB_TOKEN };
-        const baseUrl = creds.GITLAB_URL || "https://gitlab.com";
+        // Normalize trailing slash(es) so a pasted "https://gl.corp.com/" (or even
+        // the canonical "https://gitlab.com/") does not produce a double-slash
+        // "//api/v4". The /+$ also collapses accidental multi-trailing-slash input.
+        const baseUrl = (creds.GITLAB_URL || "https://gitlab.com").replace(/\/+$/, "");
         if (baseUrl !== "https://gitlab.com")
             env.GITLAB_API_URL = `${baseUrl}/api/v4`;
         return {

package/dist/schema.d.ts

@@ -17,7 +17,7 @@ export declare const configFieldZ: z.ZodObject<{
     description: z.ZodString;
     required: z.ZodOptional<z.ZodBoolean>;
     env: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
+}, "strict", z.ZodTypeAny, {
     description: string;
     required?: boolean | undefined;
     env?: string | undefined;
@@ -30,12 +30,14 @@ export declare const configFieldZ: z.ZodObject<{
  * Zod schema for tool metadata (name, description, input_schema).
  * Note: `handler` is intentionally omitted — Zod schemas validate
  * serializable data (JSON import/export), not runtime function refs.
+ *
+ * .strict() to match the published Tool `$def`'s `additionalProperties: false`.
  */
 export declare const toolZ: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
     input_schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, "strip", z.ZodTypeAny, {
+}, "strict", z.ZodTypeAny, {
     description: string;
     name: string;
     input_schema: Record<string, unknown>;
@@ -179,7 +181,7 @@ export declare const skillZ: z.ZodEffects<z.ZodObject<{
         description: z.ZodString;
         required: z.ZodOptional<z.ZodBoolean>;
         env: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
+    }, "strict", z.ZodTypeAny, {
         description: string;
         required?: boolean | undefined;
         env?: string | undefined;
@@ -192,7 +194,7 @@ export declare const skillZ: z.ZodEffects<z.ZodObject<{
         name: z.ZodString;
         description: z.ZodString;
         input_schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, "strip", z.ZodTypeAny, {
+    }, "strict", z.ZodTypeAny, {
         description: string;
         name: string;
         input_schema: Record<string, unknown>;
@@ -2623,7 +2625,7 @@ export declare function parseWorkflow(raw: unknown): {
     }> | undefined;
 };
 export interface WorkflowError {
-    code: "MISSING_ENTRY" | "UNKNOWN_EDGE_SOURCE" | "UNKNOWN_EDGE_TARGET" | "UNREACHABLE_NODE" | "UNKNOWN_SKILL" | "SELF_LOOP" | "UNBOUNDED_CYCLE" | "UNSUPPORTED_EVAL_POLICY" | "INVALID_INLINE_SKILL";
+    code: "MISSING_ENTRY" | "UNKNOWN_EDGE_SOURCE" | "UNKNOWN_EDGE_TARGET" | "UNREACHABLE_NODE" | "UNKNOWN_SKILL" | "SELF_LOOP" | "UNBOUNDED_CYCLE" | "AMBIGUOUS_EDGES" | "UNSUPPORTED_EVAL_POLICY" | "INVALID_INLINE_SKILL";
     message: string;
     nodeId?: string;
 }
@@ -3402,6 +3404,11 @@ export declare const skillJsonSchema: {
         readonly McpServerConfig: {
             readonly type: "object";
             readonly description: "External MCP server definition.";
+            readonly anyOf: readonly [{
+                readonly required: readonly ["command"];
+            }, {
+                readonly required: readonly ["url"];
+            }];
             readonly additionalProperties: false;
             readonly properties: {
                 readonly type: {

package/dist/schema.js

@@ -14,21 +14,32 @@ export { sourceZ };
 export { workflowInputsZ };
 // ─── Zod Schemas ─────────────────────────────────────────────────
 export const jsonSchemaZ = z.record(z.unknown());
-export const configFieldZ = z.object({
+// .strict() to match the published skill JSON Schema's ConfigField
+// `additionalProperties: false`. Without it Zod silently STRIPPED an unknown
+// nested key while ajv REJECTED it (the #214/#225 divergence class, missed for
+// configFieldZ/toolZ). custom-loader.ts builds Skill objects from frontmatter
+// and never runs these schemas, so tightening is safe downstream.
+export const configFieldZ = z
+    .object({
     description: z.string(),
     required: z.boolean().optional(),
     env: z.string().optional(),
-});
+})
+    .strict();
 /**
  * Zod schema for tool metadata (name, description, input_schema).
  * Note: `handler` is intentionally omitted — Zod schemas validate
  * serializable data (JSON import/export), not runtime function refs.
+ *
+ * .strict() to match the published Tool `$def`'s `additionalProperties: false`.
  */
-export const toolZ = z.object({
+export const toolZ = z
+    .object({
     name: z.string().min(1),
     description: z.string(),
     input_schema: jsonSchemaZ,
-});
+})
+    .strict();
 export const skillCategoryZ = z.enum(SKILL_CATEGORIES);
 export const mcpServerConfigZ = z
     .object({
@@ -344,6 +355,32 @@ export function validateWorkflow(workflow, knownSkills) {
             });
         }
     }
+    // Edge determinism: a node with two or more out-edges that have no `when`
+    // clause is ambiguous. The executor's resolveNext picks the first such edge
+    // and silently drops the rest, wasting a route eval on a deterministic hop
+    // and leaving the other targets unreachable. Reject it at load time so the
+    // author sees the problem instead of getting a silent first-edge-wins.
+    // Only count edges whose source is a real node (broken sources are already
+    // reported above as UNKNOWN_EDGE_SOURCE).
+    const unconditionalByNode = new Map();
+    for (const edge of workflow.edges) {
+        if (!nodeIds.has(edge.from))
+            continue;
+        if (edge.when)
+            continue;
+        const list = unconditionalByNode.get(edge.from) ?? [];
+        list.push(edge.to);
+        unconditionalByNode.set(edge.from, list);
+    }
+    for (const [from, targets] of unconditionalByNode) {
+        if (targets.length > 1) {
+            errors.push({
+                code: "AMBIGUOUS_EDGES",
+                message: `Node "${from}" has ${targets.length} unconditional out-edges (to ${targets.join(", ")}); add a 'when' clause to all but one so routing is deterministic`,
+                nodeId: from,
+            });
+        }
+    }
     // Don't check reachability if there are structural errors
     if (errors.length > 0)
         return errors;
@@ -1009,6 +1046,11 @@ export const skillJsonSchema = {
         McpServerConfig: {
             type: "object",
             description: "External MCP server definition.",
+            // An MCP server must declare command (stdio) or url (http), mirroring
+            // mcpServerConfigZ.refine(c => c.command || c.url) and the workflow
+            // inline-skill mcp block. Without this the published skill.json accepted a
+            // transport-less mcp block the runtime parser rejects (Zod<->ajv drift).
+            anyOf: [{ required: ["command"] }, { required: ["url"] }],
             additionalProperties: false,
             properties: {
                 type: {

package/dist/source-resolver.d.ts

@@ -7,6 +7,13 @@
  * or `node:crypto` into bundlers that target the browser.
  */
 import type { ResolvedSource, Source, SourceResolutionContext, SourceResolutionMap } from "./sources.js";
+/**
+ * Error-message prefix used when a `url:` source cannot be fetched in
+ * `--offline` mode. Exported so callers that intentionally degrade to a default
+ * on this one failure (e.g. `templates.ts`) can detect it without coupling to
+ * the full message text.
+ */
+export declare const SOURCE_OFFLINE_REQUIRES_FETCH = "SOURCE_OFFLINE_REQUIRES_FETCH";
 /**
  * Produce a stable 16-hex-char hash of `content` for use as a cache key /
  * change-detection ID.

package/dist/source-resolver.js

@@ -12,6 +12,13 @@ import * as path from "node:path";
 import { normalizeSource } from "./sources.js";
 /** Schemes a `url:` source is allowed to use. Everything else is rejected. */
 const ALLOWED_URL_SCHEMES = new Set(["http:", "https:"]);
+/**
+ * Error-message prefix used when a `url:` source cannot be fetched in
+ * `--offline` mode. Exported so callers that intentionally degrade to a default
+ * on this one failure (e.g. `templates.ts`) can detect it without coupling to
+ * the full message text.
+ */
+export const SOURCE_OFFLINE_REQUIRES_FETCH = "SOURCE_OFFLINE_REQUIRES_FETCH";
 /** Default DNS resolver used when the context does not inject one. */
 const defaultDnsLookup = async (hostname) => {
     const records = await dns.lookup(hostname, { all: true });
@@ -80,7 +87,7 @@ export async function resolveSource(source, fieldPath, ctx) {
     }
     if (kind === "url") {
         if (ctx.offline) {
-            throw new Error(`SOURCE_OFFLINE_REQUIRES_FETCH: cannot fetch ${value} in --offline mode (referenced by ${fieldPath}).`);
+            throw new Error(`${SOURCE_OFFLINE_REQUIRES_FETCH}: cannot fetch ${value} in --offline mode (referenced by ${fieldPath}).`);
         }
         // Validate type field on tagged URL forms — v1 only accepts "fetch" (the default).
         if (typeof source === "object" && "url" in source && source.type && source.type !== "fetch") {

package/dist/templates.d.ts

@@ -34,7 +34,12 @@ export interface SourceLoadOptions {
 }
 /**
  * Load a template from a file path or URL.
- * Returns the default if source is empty or loading fails.
+ *
+ * Returns the default only when the source is empty/unset, or when a URL source
+ * is intentionally skipped under `--offline`. A CONFIGURED source that fails to
+ * resolve (404, 403, SSRF block, read error) now THROWS instead of silently
+ * degrading to the built-in default — a typo'd or unauthorized template URL is
+ * a misconfiguration, not a no-op. This matches the executor's Source handling.
  *
  * Accepts the legacy `cwd?: string` signature for backward compat.
  */
@@ -52,6 +57,9 @@ export declare function resolveTemplates(config: {
  * Returns { resolved, urls } — resolved text for all sources; urls is kept
  * for API compat but will be empty since URLs now resolve eagerly.
  *
+ * A configured source that fails to resolve THROWS (matching the executor and
+ * `loadTemplate`); only the intentional `--offline` URL skip is swallowed.
+ *
  * Accepts the legacy `cwd?: string` signature for backward compat.
  */
 export declare function loadAdditionalContext(sources: string[], options?: SourceLoadOptions | string): Promise<{

package/dist/templates.js

@@ -13,7 +13,7 @@
  */
 import * as path from "node:path";
 import { classifySource } from "./sources.js";
-import { resolveSource } from "./source-resolver.js";
+import { resolveSource, SOURCE_OFFLINE_REQUIRES_FETCH } from "./source-resolver.js";
 import { consoleLogger } from "./types.js";
 export const DEFAULT_ISSUE_TEMPLATE = `## Summary
 <!-- One-line description of the issue -->
@@ -61,9 +61,26 @@ function buildCtx(options) {
         logger: consoleLogger,
     };
 }
+/**
+ * True when a resolution error is the intentional `--offline` skip of a URL
+ * source. Offline mode is the one failure we deliberately swallow into the
+ * fallback: the operator explicitly asked to skip URL Sources. Every other
+ * failure (404/403/SSRF block/read error/unreachable) is a real
+ * misconfiguration and must surface, matching the executor's per-node Source
+ * resolution which hard-throws on all of these.
+ */
+function isOfflineSkip(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return msg.startsWith(SOURCE_OFFLINE_REQUIRES_FETCH);
+}
 /**
  * Load a template from a file path or URL.
- * Returns the default if source is empty or loading fails.
+ *
+ * Returns the default only when the source is empty/unset, or when a URL source
+ * is intentionally skipped under `--offline`. A CONFIGURED source that fails to
+ * resolve (404, 403, SSRF block, read error) now THROWS instead of silently
+ * degrading to the built-in default — a typo'd or unauthorized template URL is
+ * a misconfiguration, not a no-op. This matches the executor's Source handling.
  *
  * Accepts the legacy `cwd?: string` signature for backward compat.
  */
@@ -76,9 +93,12 @@ export async function loadTemplate(source, fallback, options = {}) {
         return resolved.content;
     }
     catch (err) {
+        if (isOfflineSkip(err)) {
+            console.warn(`[templates] Skipping URL template in --offline mode, using default.`);
+            return fallback;
+        }
         const msg = err instanceof Error ? err.message : String(err);
-        console.warn(`[templates] Failed to load template: ${msg}, using default`);
-        return fallback;
+        throw new Error(`Failed to load configured template "${source.trim()}": ${msg}`);
     }
 }
 /**
@@ -98,6 +118,9 @@ export async function resolveTemplates(config, options = {}) {
  * Returns { resolved, urls } — resolved text for all sources; urls is kept
  * for API compat but will be empty since URLs now resolve eagerly.
  *
+ * A configured source that fails to resolve THROWS (matching the executor and
+ * `loadTemplate`); only the intentional `--offline` URL skip is swallowed.
+ *
  * Accepts the legacy `cwd?: string` signature for backward compat.
  */
 export async function loadAdditionalContext(sources, options = {}) {
@@ -123,8 +146,15 @@ export async function loadAdditionalContext(sources, options = {}) {
                 }
             }
             catch (err) {
+                // Offline skip of a URL source is intentional; everything else (404,
+                // 403, SSRF block, read error) is a misconfiguration and must surface
+                // rather than silently dropping the configured context document.
+                if (isOfflineSkip(err)) {
+                    console.warn(`[templates] Skipping URL context source "${trimmed}" in --offline mode.`);
+                    continue;
+                }
                 const msg = err instanceof Error ? err.message : String(err);
-                console.warn(`[templates] Failed to load context source: ${msg}`);
+                throw new Error(`Failed to load configured context source "${trimmed}": ${msg}`);
             }
         }
     }

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.106",
+  "version": "0.1.108",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"
   },
   "description": "Skill library, DAG workflow orchestration, and E2E browser testing powered by Claude",
   "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
   "exports": {
     ".": "./dist/index.js",
     "./browser": "./dist/browser.js",
@@ -15,7 +18,8 @@
     "./workflows": "./dist/workflows/index.js",
     "./testing": "./dist/testing.js",
     "./schema": "./dist/schema.js",
-    "./new": "./dist/cli/new.js"
+    "./new": "./dist/cli/new.js",
+    "./package.json": "./package.json"
   },
   "typesVersions": {
     "*": {