@sweny-ai/core 0.1.76 → 0.1.78

package/dist/templates.js

@@ -1,13 +1,15 @@
 /**
- * Template loading for issues and PRs.
+ * Template + rules/context loading for the CLI.
  *
- * Templates can come from:
+ * Templates and additional-context documents can come from:
  *   1. Local file path (relative to repo root)
  *   2. URL (fetched at runtime)
- *   3. Built-in defaults
+ *   3. Built-in defaults / inline text
  *
- * Delegates to sources.ts for actual resolution; this module provides
- * backwards-compatible wrappers with fallback semantics.
+ * Delegates to source-resolver.ts for the actual fetch. Fix #16: both
+ * `loadTemplate` and `loadAdditionalContext` now honor `offline` and
+ * `fetchAuth` the same way the executor's per-node Sources do, so CLI-level
+ * rules/context stay consistent with everything the executor touches later.
  */
 import * as path from "node:path";
 import { classifySource } from "./sources.js";
@@ -50,39 +52,43 @@ export const DEFAULT_PR_TEMPLATE = `## Summary
 ## Related Issues
 Fixes #
 `;
-/** Default resolution context used by template helpers. */
-function defaultCtx(cwd) {
+function buildCtx(options) {
     return {
-        cwd,
-        env: process.env,
-        authConfig: {},
-        offline: false,
+        cwd: options.cwd ?? process.cwd(),
+        env: options.env ?? process.env,
+        authConfig: options.fetchAuth ?? {},
+        offline: options.offline ?? false,
         logger: consoleLogger,
     };
 }
 /**
  * Load a template from a file path or URL.
  * Returns the default if source is empty or loading fails.
+ *
+ * Accepts the legacy `cwd?: string` signature for backward compat.
  */
-export async function loadTemplate(source, fallback, cwd = process.cwd()) {
+export async function loadTemplate(source, fallback, options = {}) {
     if (!source || source.trim() === "")
         return fallback;
+    const opts = typeof options === "string" ? { cwd: options } : options;
     try {
-        const resolved = await resolveSource(source.trim(), "template", defaultCtx(cwd));
+        const resolved = await resolveSource(source.trim(), "template", buildCtx(opts));
         return resolved.content;
     }
     catch (err) {
-        console.warn(`[templates] Failed to load template: ${err.message}, using default`);
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`[templates] Failed to load template: ${msg}, using default`);
         return fallback;
     }
 }
 /**
  * Resolve issue and PR templates from config.
  */
-export async function resolveTemplates(config, cwd) {
+export async function resolveTemplates(config, options = {}) {
+    const opts = typeof options === "string" ? { cwd: options } : options;
     const [issueTemplate, prTemplate] = await Promise.all([
-        loadTemplate(config.issueTemplate, DEFAULT_ISSUE_TEMPLATE, cwd),
-        loadTemplate(config.prTemplate, DEFAULT_PR_TEMPLATE, cwd),
+        loadTemplate(config.issueTemplate, DEFAULT_ISSUE_TEMPLATE, opts),
+        loadTemplate(config.prTemplate, DEFAULT_PR_TEMPLATE, opts),
     ]);
     return { issueTemplate, prTemplate };
 }
@@ -91,12 +97,15 @@ export async function resolveTemplates(config, cwd) {
  * Each source is resolved eagerly (including URLs) and wrapped with a header.
  * Returns { resolved, urls } — resolved text for all sources; urls is kept
  * for API compat but will be empty since URLs now resolve eagerly.
+ *
+ * Accepts the legacy `cwd?: string` signature for backward compat.
  */
-export async function loadAdditionalContext(sources, cwd = process.cwd()) {
+export async function loadAdditionalContext(sources, options = {}) {
     if (sources.length === 0)
         return { resolved: "", urls: [] };
+    const opts = typeof options === "string" ? { cwd: options } : options;
     const parts = [];
-    const ctx = defaultCtx(cwd);
+    const ctx = buildCtx(opts);
     for (const source of sources) {
         const trimmed = source.trim();
         if (!trimmed)
@@ -114,7 +123,8 @@ export async function loadAdditionalContext(sources, cwd = process.cwd()) {
                 }
             }
             catch (err) {
-                console.warn(`[templates] Failed to load context source: ${err.message}`);
+                const msg = err instanceof Error ? err.message : String(err);
+                console.warn(`[templates] Failed to load context source: ${msg}`);
             }
         }
     }

package/dist/testing.d.ts

@@ -38,6 +38,8 @@ export interface MockClaudeOptions {
     routes?: Record<string, string>;
     /** Workflow definition — enables instruction-based node matching (required for branching workflows) */
     workflow?: Workflow;
+    /** Scripted handler for `ask()` calls. */
+    ask?: (instruction: string, context: Record<string, unknown>) => string;
 }
 /**
  * A mock Claude client that follows a script.
@@ -51,6 +53,7 @@ export declare class MockClaude implements Claude {
     private responses;
     private routes;
     private instructionMap;
+    private askFn?;
     constructor(opts: MockClaudeOptions);
     /** Returns the order in which nodes were executed */
     get executedNodes(): string[];
@@ -68,6 +71,10 @@ export declare class MockClaude implements Claude {
             description: string;
         }[];
     }): Promise<string>;
+    ask(opts: {
+        instruction: string;
+        context: Record<string, unknown>;
+    }): Promise<string>;
     /**
      * Identify which node is being executed.
      *

package/dist/testing.js

@@ -32,9 +32,11 @@ export class MockClaude {
     responses;
     routes;
     instructionMap; // instruction text → node ID
+    askFn;
     constructor(opts) {
         this.responses = opts.responses;
         this.routes = opts.routes ?? {};
+        this.askFn = opts.ask;
         // Build reverse map: instruction → node ID (for accurate matching in branching workflows)
         this.instructionMap = new Map();
         if (opts.workflow) {
@@ -98,6 +100,11 @@ export class MockClaude {
         // Default: first choice
         return opts.choices[0].id;
     }
+    async ask(opts) {
+        if (this.askFn)
+            return this.askFn(opts.instruction, opts.context);
+        return "";
+    }
     /**
      * Identify which node is being executed.
      *

package/dist/types.d.ts

@@ -73,6 +73,50 @@ export interface NodeVerify {
     /** Each assertion must hold against `result.data`. */
     output_matches?: OutputMatch[];
 }
+/**
+ * Machine-checked pre-condition for a node.
+ *
+ * Evaluated by the executor BEFORE the LLM runs. If any declared check fails,
+ * the node is marked `failed` (or `skipped` when `on_fail: "skip"`) and the
+ * LLM is never invoked.
+ *
+ * Path roots resolve against the cross-node context map:
+ *   { input: <runtime input>, [priorNodeId]: <data of prior node>, ... }
+ *
+ * Reuses the same path grammar as `verify` (dotted segments, `[*]` wildcard,
+ * optional `all:`/`any:` prefix).
+ */
+export interface NodeRequires {
+    /** Listed paths must be present and non-null in the context map. */
+    output_required?: string[];
+    /** Each assertion must hold against the context map. */
+    output_matches?: OutputMatch[];
+    /** Action when checks fail. Default: "fail". */
+    on_fail?: "fail" | "skip";
+}
+/**
+ * Node-local retry on verify failure.
+ *
+ * Re-runs the LLM up to `max` additional times, prepending feedback derived
+ * from the verify failure. Triggered ONLY by verify failure — not by tool/API
+ * errors and not by `requires` failure.
+ *
+ * `instruction` shapes the feedback preamble:
+ *   - omitted        → default "## Previous attempt failed verification..."
+ *   - string         → static text + verify error
+ *   - { auto: true } → LLM-generated diagnosis from default reflection prompt
+ *   - { reflect: s } → LLM-generated diagnosis from author-provided prompt
+ */
+export interface NodeRetry {
+    /** Maximum number of retry attempts after the initial run. Must be ≥ 1. */
+    max: number;
+    /** Preamble shape — see interface docs. */
+    instruction?: string | {
+        auto: true;
+    } | {
+        reflect: string;
+    };
+}
 /**
  * A single output assertion. Exactly one of `equals | in | matches` must be set.
  *
@@ -106,6 +150,10 @@ export interface Node {
     context?: NodeSources;
     /** Machine-checked post-conditions. Enforced by the executor after the LLM finishes. */
     verify?: NodeVerify;
+    /** Machine-checked pre-conditions. Enforced by the executor before the LLM runs. */
+    requires?: NodeRequires;
+    /** Node-local retry on verify failure (with optional autonomous reflection). */
+    retry?: NodeRetry;
 }
 /** An edge connecting two nodes */
 export interface Edge {
@@ -153,6 +201,18 @@ export interface ToolCall {
     tool: string;
     input: unknown;
     output?: unknown;
+    /**
+     * Authoritative outcome of the tool invocation.
+     *
+     * When present, this is the source of truth for `verify` checks — the
+     * output-shape heuristic is a legacy fallback only. Set by the Claude
+     * runtime on tool completion: "success" when the tool returned normally,
+     * "error" when it threw or the MCP server returned is_error=true.
+     *
+     * Absent status indicates a legacy or hand-constructed ToolCall — verify
+     * falls back to inspecting `output` for an `error` key.
+     */
+    status?: "success" | "error";
 }
 export type ExecutionEvent = {
     type: "workflow:start";
@@ -182,6 +242,12 @@ export type ExecutionEvent = {
     type: "node:progress";
     node: string;
     message: string;
+} | {
+    type: "node:retry";
+    node: string;
+    attempt: number;
+    reason: string;
+    preamble: string;
 } | {
     type: "route";
     from: string;
@@ -200,6 +266,8 @@ export interface TraceStep {
     status: "success" | "failed" | "skipped";
     /** 1-based iteration count (2 = second time this node ran) */
     iteration: number;
+    /** 0-indexed retry attempt for this iteration. Absent when no retry fired. */
+    retryAttempt?: number;
 }
 /** A routing decision between nodes */
 export interface TraceEdge {
@@ -245,6 +313,14 @@ export interface Claude {
             description: string;
         }[];
     }): Promise<string>;
+    /**
+     * Single-completion free-text query. No tools, no output schema.
+     * Used by the executor to generate retry strategies in autonomous reflection mode.
+     */
+    ask(opts: {
+        instruction: string;
+        context: Record<string, unknown>;
+    }): Promise<string>;
 }
 export interface McpServerConfig {
     type?: "stdio" | "http";

package/dist/verify.d.ts

@@ -8,6 +8,7 @@ export type Resolution = {
     reason: string;
 };
 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;

package/dist/verify.js

@@ -69,19 +69,35 @@ export function resolvePath(data, path) {
     }
     return { ok: true, mode: parsed.mode, values: current };
 }
-// A tool call "succeeded" when its output does not carry a non-null `error` field.
-// `{ error: null }` and `{ error: false }` are treated as success — many real
-// tools include the key with a null sentinel.
-function isErrorOutput(output) {
+// Legacy output-shape heuristic: a tool call "succeeded" when its output
+// does not carry a non-null `error` field. Kept as a fallback for ToolCall
+// records that predate the explicit `status` field (hand-constructed in
+// tests, older runtimes). The Claude runtime now sets `status` directly.
+export function isErrorOutput(output) {
     if (!output || typeof output !== "object")
         return false;
     const err = output.error;
     return err !== undefined && err !== null && err !== false;
 }
+/**
+ * A tool call is considered successful when:
+ *   - explicit `status === "success"`, OR
+ *   - no explicit status AND output does not look like an error.
+ *
+ * `status` is authoritative. It's the only signal we have for external MCP
+ * tools whose structured output isn't exposed to the workflow runtime.
+ */
+function didSucceed(c) {
+    if (c.status === "error")
+        return false;
+    if (c.status === "success")
+        return true;
+    return !isErrorOutput(c.output);
+}
 function succeededTools(toolCalls) {
     const names = new Set();
     for (const c of toolCalls) {
-        if (!isErrorOutput(c.output))
+        if (didSucceed(c))
             names.add(c.tool);
     }
     return names;
@@ -180,8 +196,30 @@ export function checkOutputRequired(paths, data) {
         return null;
     return `output_required: ${failures.join("; ")}`;
 }
+/**
+ * Cap on `verify.output_matches[].matches` source length.
+ *
+ * `matches` is user-supplied through workflow YAML, including marketplace
+ * workflows. A pathological pattern like `(a+)+$` causes exponential
+ * backtracking in V8's regex engine. Capping the source length is a cheap,
+ * useful defense — well-formed verify regexes are tens of characters at
+ * most. Patterns longer than this are almost always either generated junk
+ * or a deliberate ReDoS attempt; either way, refusing to compile is safer
+ * than executing them.
+ *
+ * Caveat: length alone does NOT prevent all ReDoS — a 12-char pattern like
+ * `(a+)+$` is still catastrophic against the right input. Future work:
+ * gate compilation through `safe-regex` or use the `re2` engine for
+ * marketplace inputs. The cap closes the obvious abuse surface without
+ * adding a runtime dep right now.
+ */
+const MAX_REGEX_SOURCE_LENGTH = 1000;
 function compileMatch(m) {
     if (m.matches !== undefined) {
+        if (m.matches.length > MAX_REGEX_SOURCE_LENGTH) {
+            throw new Error(`regex source exceeds ${MAX_REGEX_SOURCE_LENGTH} characters (got ${m.matches.length}); ` +
+                `tighten the pattern to avoid catastrophic-backtracking risk`);
+        }
         // Throws synchronously if the regex source is invalid; surfaced as a
         // verify failure rather than a crash because the executor catches.
         return { match: m, regex: new RegExp(m.matches) };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.76",
+  "version": "0.1.78",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"
@@ -46,10 +46,11 @@
     "dist"
   ],
   "scripts": {
-    "build": "rm -rf dist && tsc && cp src/workflows/*.yml dist/workflows/ && node scripts/build-workflow-browser.mjs",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && cp src/workflows/*.yml dist/workflows/ && node scripts/build-workflow-browser.mjs && node scripts/write-public-schema.mjs",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run --exclude 'src/__tests__/integration/**'",
-    "test:integration": "vitest run --config vitest.integration.config.ts"
+    "test": "vitest run --exclude 'src/__tests__/integration/**' --exclude 'dist/**'",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
+    "check:schema-drift": "node scripts/write-public-schema.mjs && git diff --exit-code -- ../../spec/public/schemas/workflow.json"
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.114",
@@ -61,6 +62,9 @@
   },
   "devDependencies": {
     "@anthropic-ai/claude-code": "^2.1.114",
+    "ajv": "^8.18.0",
+    "esbuild": "^0.28.0",
+    "prettier": "^3.8.3",
     "vitest": "^4.1.4"
   },
   "publishConfig": {

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

@@ -1,11 +0,0 @@
-/**
- * Rules / Context Cascade + max_turns Tests
- *
- * Covers the spec sections:
- * - Workflow > Rules & Context
- * - Workflow > Runtime Input (rules/context)
- * - Nodes > Max Turns Semantics
- * - Nodes > Rules & Context (cascade + `only` flag)
- * - Nodes > Input Augmentation (assembly order)
- */
-export {};