@renseiai/agentfactory 0.8.7 → 0.8.8

package/dist/src/workflow/expression/index.js

@@ -0,0 +1,71 @@
+/**
+ * Expression Parser & Evaluator — Public API
+ *
+ * Parses Handlebars-style condition strings from WorkflowDefinition
+ * transitions into a typed AST, and evaluates them within a sandboxed
+ * context.
+ *
+ * @example
+ * ```ts
+ * import { parseExpression, evaluateCondition, buildEvaluationContext } from './expression/index.js'
+ *
+ * const ast = parseExpression("{{ hasLabel('bug') and priority gt 3 }}")
+ * // => BinaryOp(AND, FunctionCall("hasLabel", [StringLiteral("bug")]), BinaryOp(GT, ...))
+ *
+ * const ctx = buildEvaluationContext(issue, phaseState)
+ * const result = evaluateCondition("{{ hasLabel('bug') }}", ctx)
+ * // => true or false
+ * ```
+ */
+import { tokenize } from './lexer.js';
+import { parse } from './parser.js';
+import { evaluate } from './evaluator.js';
+export { ParseError, tokenize } from './lexer.js';
+// ---------------------------------------------------------------------------
+// Re-exports — Parser
+// ---------------------------------------------------------------------------
+export { parse } from './parser.js';
+// ---------------------------------------------------------------------------
+// Re-exports — Evaluator
+// ---------------------------------------------------------------------------
+export { evaluate, EvaluationError } from './evaluator.js';
+export { buildEvaluationContext } from './context.js';
+// ---------------------------------------------------------------------------
+// Re-exports — Helpers
+// ---------------------------------------------------------------------------
+export { createBuiltinHelpers } from './helpers.js';
+// ---------------------------------------------------------------------------
+// Convenience entry points
+// ---------------------------------------------------------------------------
+/**
+ * Parse a condition string into an AST in a single call.
+ *
+ * Combines tokenization and parsing. Accepts strings with or without
+ * `{{ }}` delimiters.
+ *
+ * @param condition - The condition string to parse.
+ * @returns The root AST node.
+ * @throws {ParseError} on invalid input with position information.
+ */
+export function parseExpression(condition) {
+    const tokens = tokenize(condition);
+    return parse(tokens);
+}
+/**
+ * Parse and evaluate a condition string, returning a boolean result.
+ *
+ * This is the primary entry point for workflow transition evaluation.
+ * It combines parsing and evaluation in one call, and coerces the
+ * result to a boolean.
+ *
+ * @param condition - The condition string (with or without `{{ }}`).
+ * @param context   - The sandboxed evaluation context.
+ * @returns `true` if the condition is satisfied, `false` otherwise.
+ * @throws {ParseError} on syntax errors.
+ * @throws {EvaluationError} on runtime errors (unknown functions, type mismatches).
+ */
+export function evaluateCondition(condition, context) {
+    const ast = parseExpression(condition);
+    const result = evaluate(ast, context);
+    return Boolean(result);
+}

package/dist/src/workflow/expression/lexer.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Expression Lexer (Tokenizer)
+ *
+ * Converts a condition string (with optional `{{ }}` delimiters) into a
+ * flat token stream. Each token carries source-position info for error
+ * reporting downstream.
+ */
+export type TokenType = 'Identifier' | 'BooleanLiteral' | 'StringLiteral' | 'NumberLiteral' | 'Operator' | 'LeftParen' | 'RightParen' | 'Comma' | 'EOF';
+/** Source position within the *inner* expression (after delimiter stripping). */
+export interface SourcePosition {
+    /** 0-based character offset */
+    readonly offset: number;
+    /** 1-based column (same as offset + 1 since expressions are single-line) */
+    readonly column: number;
+}
+export interface Token {
+    readonly type: TokenType;
+    readonly value: string;
+    readonly position: SourcePosition;
+}
+/**
+ * Error thrown when the lexer or parser encounters invalid input.
+ * Carries source-position information for precise error messages.
+ */
+export declare class ParseError extends Error {
+    readonly position: SourcePosition;
+    constructor(message: string, position: SourcePosition);
+}
+/**
+ * Tokenize a condition string into a flat token array.
+ *
+ * @param input - The condition string, optionally wrapped in `{{ }}`.
+ * @returns An array of tokens ending with an `EOF` token.
+ * @throws {ParseError} on unexpected characters or unterminated strings.
+ */
+export declare function tokenize(input: string): Token[];
+//# sourceMappingURL=lexer.d.ts.map

package/dist/src/workflow/expression/lexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexer.d.ts","sourceRoot":"","sources":["../../../../src/workflow/expression/lexer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,MAAM,MAAM,SAAS,GACjB,YAAY,GACZ,gBAAgB,GAChB,eAAe,GACf,eAAe,GACf,UAAU,GACV,WAAW,GACX,YAAY,GACZ,OAAO,GACP,KAAK,CAAA;AAET,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC7B,+BAA+B;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;CAClC;AAMD;;;GAGG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;gBAErB,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc;CAKtD;AAsED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,CAsF/C"}

package/dist/src/workflow/expression/lexer.js

@@ -0,0 +1,166 @@
+/**
+ * Expression Lexer (Tokenizer)
+ *
+ * Converts a condition string (with optional `{{ }}` delimiters) into a
+ * flat token stream. Each token carries source-position info for error
+ * reporting downstream.
+ */
+// ---------------------------------------------------------------------------
+// ParseError
+// ---------------------------------------------------------------------------
+/**
+ * Error thrown when the lexer or parser encounters invalid input.
+ * Carries source-position information for precise error messages.
+ */
+export class ParseError extends Error {
+    position;
+    constructor(message, position) {
+        super(`${message} at column ${position.column}`);
+        this.name = 'ParseError';
+        this.position = position;
+    }
+}
+// ---------------------------------------------------------------------------
+// Keyword sets
+// ---------------------------------------------------------------------------
+const OPERATORS = new Set([
+    'and', 'or', 'not',
+    'eq', 'neq', 'gt', 'lt', 'gte', 'lte',
+]);
+const BOOLEAN_LITERALS = new Set(['true', 'false']);
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function isWhitespace(ch) {
+    return ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r';
+}
+function isDigit(ch) {
+    return ch >= '0' && ch <= '9';
+}
+function isIdentStart(ch) {
+    return (ch >= 'a' && ch <= 'z') ||
+        (ch >= 'A' && ch <= 'Z') ||
+        ch === '_';
+}
+function isIdentChar(ch) {
+    return isIdentStart(ch) || isDigit(ch);
+}
+function pos(offset) {
+    return { offset, column: offset + 1 };
+}
+// ---------------------------------------------------------------------------
+// Strip delimiters
+// ---------------------------------------------------------------------------
+/**
+ * Remove the `{{ }}` Handlebars-style delimiters from a condition string.
+ * Returns the inner content and the offset of the inner content within
+ * the original string (so positions map back correctly).
+ */
+function stripDelimiters(input) {
+    const trimmed = input.trim();
+    if (trimmed.startsWith('{{') && trimmed.endsWith('}}')) {
+        const openIdx = input.indexOf('{{');
+        // +2 to skip past the opening {{
+        const innerStart = openIdx + 2;
+        const closeIdx = input.lastIndexOf('}}');
+        return {
+            inner: input.slice(innerStart, closeIdx),
+            offset: innerStart,
+        };
+    }
+    // No delimiters — treat as raw expression
+    return { inner: input, offset: 0 };
+}
+// ---------------------------------------------------------------------------
+// Tokenize
+// ---------------------------------------------------------------------------
+/**
+ * Tokenize a condition string into a flat token array.
+ *
+ * @param input - The condition string, optionally wrapped in `{{ }}`.
+ * @returns An array of tokens ending with an `EOF` token.
+ * @throws {ParseError} on unexpected characters or unterminated strings.
+ */
+export function tokenize(input) {
+    const { inner } = stripDelimiters(input);
+    const tokens = [];
+    let i = 0;
+    while (i < inner.length) {
+        const ch = inner[i];
+        // Skip whitespace
+        if (isWhitespace(ch)) {
+            i++;
+            continue;
+        }
+        // Single-quoted string literal
+        if (ch === "'") {
+            const start = i;
+            i++; // skip opening quote
+            let value = '';
+            while (i < inner.length && inner[i] !== "'") {
+                value += inner[i];
+                i++;
+            }
+            if (i >= inner.length) {
+                throw new ParseError('Unterminated string literal', pos(start));
+            }
+            i++; // skip closing quote
+            tokens.push({ type: 'StringLiteral', value, position: pos(start) });
+            continue;
+        }
+        // Number literal
+        if (isDigit(ch) || (ch === '-' && i + 1 < inner.length && isDigit(inner[i + 1]))) {
+            const start = i;
+            if (ch === '-')
+                i++; // consume negative sign
+            while (i < inner.length && isDigit(inner[i]))
+                i++;
+            // Decimal part
+            if (i < inner.length && inner[i] === '.' && i + 1 < inner.length && isDigit(inner[i + 1])) {
+                i++; // skip dot
+                while (i < inner.length && isDigit(inner[i]))
+                    i++;
+            }
+            tokens.push({ type: 'NumberLiteral', value: inner.slice(start, i), position: pos(start) });
+            continue;
+        }
+        // Identifiers, keywords, operators, boolean literals
+        if (isIdentStart(ch)) {
+            const start = i;
+            while (i < inner.length && isIdentChar(inner[i]))
+                i++;
+            const word = inner.slice(start, i);
+            if (BOOLEAN_LITERALS.has(word)) {
+                tokens.push({ type: 'BooleanLiteral', value: word, position: pos(start) });
+            }
+            else if (OPERATORS.has(word)) {
+                tokens.push({ type: 'Operator', value: word, position: pos(start) });
+            }
+            else {
+                tokens.push({ type: 'Identifier', value: word, position: pos(start) });
+            }
+            continue;
+        }
+        // Parentheses
+        if (ch === '(') {
+            tokens.push({ type: 'LeftParen', value: '(', position: pos(i) });
+            i++;
+            continue;
+        }
+        if (ch === ')') {
+            tokens.push({ type: 'RightParen', value: ')', position: pos(i) });
+            i++;
+            continue;
+        }
+        // Comma
+        if (ch === ',') {
+            tokens.push({ type: 'Comma', value: ',', position: pos(i) });
+            i++;
+            continue;
+        }
+        // Unknown character
+        throw new ParseError(`Unexpected character '${ch}'`, pos(i));
+    }
+    tokens.push({ type: 'EOF', value: '', position: pos(i) });
+    return tokens;
+}

package/dist/src/workflow/expression/parser.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Expression Parser (Recursive Descent)
+ *
+ * Parses a token stream (produced by the lexer) into a typed AST.
+ *
+ * Operator precedence (lowest to highest):
+ *   1. `or`
+ *   2. `and`
+ *   3. comparisons: `eq`, `neq`, `gt`, `lt`, `gte`, `lte`
+ *   4. `not` (unary prefix)
+ *   5. primary: literals, variable refs, function calls, parenthesized exprs
+ */
+import type { ASTNode } from './ast.js';
+import type { Token } from './lexer.js';
+/**
+ * Parse a token stream into an AST.
+ *
+ * @param tokens - Token array produced by `tokenize()`.
+ * @returns The root AST node.
+ * @throws {ParseError} on syntax errors.
+ */
+export declare function parse(tokens: Token[]): ASTNode;
+//# sourceMappingURL=parser.d.ts.map

package/dist/src/workflow/expression/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../../src/workflow/expression/parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AACvC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAyLvC;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAkB9C"}

package/dist/src/workflow/expression/parser.js

@@ -0,0 +1,181 @@
+/**
+ * Expression Parser (Recursive Descent)
+ *
+ * Parses a token stream (produced by the lexer) into a typed AST.
+ *
+ * Operator precedence (lowest to highest):
+ *   1. `or`
+ *   2. `and`
+ *   3. comparisons: `eq`, `neq`, `gt`, `lt`, `gte`, `lte`
+ *   4. `not` (unary prefix)
+ *   5. primary: literals, variable refs, function calls, parenthesized exprs
+ */
+import { ParseError } from './lexer.js';
+// ---------------------------------------------------------------------------
+// Operator sets
+// ---------------------------------------------------------------------------
+const COMPARISON_OPERATORS = new Set(['eq', 'neq', 'gt', 'lt', 'gte', 'lte']);
+function peek(state) {
+    return state.tokens[state.pos];
+}
+function advance(state) {
+    const token = state.tokens[state.pos];
+    state.pos++;
+    return token;
+}
+function expect(state, type, value) {
+    const token = peek(state);
+    if (token.type !== type || (value !== undefined && token.value !== value)) {
+        const expected = value ? `'${value}'` : type;
+        const got = token.type === 'EOF' ? 'end of expression' : `'${token.value}'`;
+        throw new ParseError(`Expected ${expected} but got ${got}`, token.position);
+    }
+    return advance(state);
+}
+// ---------------------------------------------------------------------------
+// Grammar rules
+// ---------------------------------------------------------------------------
+/**
+ * expression := orExpr
+ */
+function parseExpression(state) {
+    return parseOr(state);
+}
+/**
+ * orExpr := andExpr ( 'or' andExpr )*
+ */
+function parseOr(state) {
+    let left = parseAnd(state);
+    while (peek(state).type === 'Operator' && peek(state).value === 'or') {
+        advance(state); // consume 'or'
+        const right = parseAnd(state);
+        left = { type: 'BinaryOp', operator: 'or', left, right };
+    }
+    return left;
+}
+/**
+ * andExpr := comparisonExpr ( 'and' comparisonExpr )*
+ */
+function parseAnd(state) {
+    let left = parseComparison(state);
+    while (peek(state).type === 'Operator' && peek(state).value === 'and') {
+        advance(state); // consume 'and'
+        const right = parseComparison(state);
+        left = { type: 'BinaryOp', operator: 'and', left, right };
+    }
+    return left;
+}
+/**
+ * comparisonExpr := unaryExpr ( ('eq'|'neq'|'gt'|'lt'|'gte'|'lte') unaryExpr )?
+ *
+ * Comparisons are non-associative (no chaining).
+ */
+function parseComparison(state) {
+    let left = parseUnary(state);
+    const token = peek(state);
+    if (token.type === 'Operator' && COMPARISON_OPERATORS.has(token.value)) {
+        const operator = advance(state).value;
+        const right = parseUnary(state);
+        left = { type: 'BinaryOp', operator, left, right };
+    }
+    return left;
+}
+/**
+ * unaryExpr := 'not' unaryExpr | primaryExpr
+ */
+function parseUnary(state) {
+    const token = peek(state);
+    if (token.type === 'Operator' && token.value === 'not') {
+        advance(state); // consume 'not'
+        const operand = parseUnary(state);
+        return { type: 'UnaryOp', operator: 'not', operand };
+    }
+    return parsePrimary(state);
+}
+/**
+ * primaryExpr := BooleanLiteral
+ *              | StringLiteral
+ *              | NumberLiteral
+ *              | Identifier '(' argList? ')'   -- function call
+ *              | Identifier                     -- variable ref
+ *              | '(' expression ')'             -- grouped sub-expression
+ */
+function parsePrimary(state) {
+    const token = peek(state);
+    // Boolean literal
+    if (token.type === 'BooleanLiteral') {
+        advance(state);
+        return { type: 'BooleanLiteral', value: token.value === 'true' };
+    }
+    // String literal
+    if (token.type === 'StringLiteral') {
+        advance(state);
+        return { type: 'StringLiteral', value: token.value };
+    }
+    // Number literal
+    if (token.type === 'NumberLiteral') {
+        advance(state);
+        return { type: 'NumberLiteral', value: Number(token.value) };
+    }
+    // Identifier — could be variable ref or function call
+    if (token.type === 'Identifier') {
+        advance(state);
+        // Check for function call: Identifier '(' ...
+        if (peek(state).type === 'LeftParen') {
+            advance(state); // consume '('
+            const args = parseArgList(state);
+            expect(state, 'RightParen');
+            return { type: 'FunctionCall', name: token.value, args };
+        }
+        return { type: 'VariableRef', name: token.value };
+    }
+    // Parenthesized sub-expression
+    if (token.type === 'LeftParen') {
+        advance(state); // consume '('
+        const expr = parseExpression(state);
+        expect(state, 'RightParen');
+        return expr;
+    }
+    // Error: unexpected token
+    const got = token.type === 'EOF' ? 'end of expression' : `'${token.value}'`;
+    throw new ParseError(`Unexpected ${got}`, token.position);
+}
+/**
+ * argList := expression ( ',' expression )*
+ *          | (empty)
+ */
+function parseArgList(state) {
+    const args = [];
+    if (peek(state).type === 'RightParen') {
+        return args;
+    }
+    args.push(parseExpression(state));
+    while (peek(state).type === 'Comma') {
+        advance(state); // consume ','
+        args.push(parseExpression(state));
+    }
+    return args;
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Parse a token stream into an AST.
+ *
+ * @param tokens - Token array produced by `tokenize()`.
+ * @returns The root AST node.
+ * @throws {ParseError} on syntax errors.
+ */
+export function parse(tokens) {
+    if (tokens.length === 0 || (tokens.length === 1 && tokens[0].type === 'EOF')) {
+        throw new ParseError('Empty expression', { offset: 0, column: 1 });
+    }
+    const state = { tokens, pos: 0 };
+    const ast = parseExpression(state);
+    // Ensure all tokens were consumed (except EOF)
+    const remaining = peek(state);
+    if (remaining.type !== 'EOF') {
+        throw new ParseError(`Unexpected '${remaining.value}' after expression`, remaining.position);
+    }
+    return ast;
+}

package/dist/src/workflow/index.d.ts

@@ -4,11 +4,18 @@
  * Declarative workflow graph definitions using YAML (v1.1 schema extension).
  * Defines phases, transitions, escalation ladder, gates, and parallelism.
  */
-export type { EscalationStrategy, PhaseDefinition, TransitionDefinition, EscalationLadderRung, EscalationConfig, GateDefinition, ParallelismGroupDefinition, WorkflowDefinition, } from './workflow-types.js';
-export { PhaseDefinitionSchema, TransitionDefinitionSchema, EscalationLadderRungSchema, EscalationConfigSchema, GateDefinitionSchema, ParallelismGroupDefinitionSchema, WorkflowDefinitionSchema, validateWorkflowDefinition, } from './workflow-types.js';
+export type { EscalationStrategy, PhaseDefinition, TransitionDefinition, EscalationLadderRung, EscalationConfig, GateDefinition, ParallelismGroupDefinition, WorkflowDefinition, BranchingDefinition, TemplateRetryConfig, TemplateTimeoutConfig, } from './workflow-types.js';
+export { PhaseDefinitionSchema, TransitionDefinitionSchema, EscalationLadderRungSchema, EscalationConfigSchema, GateDefinitionSchema, ParallelismGroupDefinitionSchema, WorkflowDefinitionSchema, BranchingDefinitionSchema, TemplateRetryConfigSchema, TemplateTimeoutConfigSchema, validateWorkflowDefinition, } from './workflow-types.js';
 export { loadWorkflowDefinitionFile, getBuiltinWorkflowDir, getBuiltinWorkflowPath, } from './workflow-loader.js';
-export type { WorkflowRegistryConfig } from './workflow-registry.js';
+export type { WorkflowRegistryConfig, WorkflowStoreSource } from './workflow-registry.js';
 export { WorkflowRegistry } from './workflow-registry.js';
 export type { TransitionContext, TransitionResult } from './transition-engine.js';
 export { evaluateTransitions } from './transition-engine.js';
+export type { BranchingResult } from './branching-router.js';
+export { evaluateBranching } from './branching-router.js';
+export { parseDuration, DurationParseError } from './duration.js';
+export type { ResolvedRetryConfig, ResolvedTimeoutConfig } from './retry-resolver.js';
+export { resolveRetryConfig, resolveTimeoutConfig } from './retry-resolver.js';
+export type { EvaluationContext } from './expression/index.js';
+export { buildEvaluationContext, evaluateCondition } from './expression/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/workflow/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/workflow/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,YAAY,EACV,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAChB,cAAc,EACd,0BAA0B,EAC1B,kBAAkB,GACnB,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EACL,qBAAqB,EACrB,0BAA0B,EAC1B,0BAA0B,EAC1B,sBAAsB,EACtB,oBAAoB,EACpB,gCAAgC,EAChC,wBAAwB,EACxB,0BAA0B,GAC3B,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EACL,0BAA0B,EAC1B,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,sBAAsB,CAAA;AAE7B,YAAY,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAA;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAEzD,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AACjF,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/workflow/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,YAAY,EACV,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAChB,cAAc,EACd,0BAA0B,EAC1B,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EACL,qBAAqB,EACrB,0BAA0B,EAC1B,0BAA0B,EAC1B,sBAAsB,EACtB,oBAAoB,EACpB,gCAAgC,EAChC,wBAAwB,EACxB,yBAAyB,EACzB,yBAAyB,EACzB,2BAA2B,EAC3B,0BAA0B,GAC3B,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EACL,0BAA0B,EAC1B,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,sBAAsB,CAAA;AAE7B,YAAY,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AACzF,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAEzD,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AACjF,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AAE5D,YAAY,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAGzD,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAGjE,YAAY,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AACrF,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAG9E,YAAY,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAC9D,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/src/workflow/index.js

@@ -4,7 +4,12 @@
  * Declarative workflow graph definitions using YAML (v1.1 schema extension).
  * Defines phases, transitions, escalation ladder, gates, and parallelism.
  */
-export { PhaseDefinitionSchema, TransitionDefinitionSchema, EscalationLadderRungSchema, EscalationConfigSchema, GateDefinitionSchema, ParallelismGroupDefinitionSchema, WorkflowDefinitionSchema, validateWorkflowDefinition, } from './workflow-types.js';
+export { PhaseDefinitionSchema, TransitionDefinitionSchema, EscalationLadderRungSchema, EscalationConfigSchema, GateDefinitionSchema, ParallelismGroupDefinitionSchema, WorkflowDefinitionSchema, BranchingDefinitionSchema, TemplateRetryConfigSchema, TemplateTimeoutConfigSchema, validateWorkflowDefinition, } from './workflow-types.js';
 export { loadWorkflowDefinitionFile, getBuiltinWorkflowDir, getBuiltinWorkflowPath, } from './workflow-loader.js';
 export { WorkflowRegistry } from './workflow-registry.js';
 export { evaluateTransitions } from './transition-engine.js';
+export { evaluateBranching } from './branching-router.js';
+// Duration parser
+export { parseDuration, DurationParseError } from './duration.js';
+export { resolveRetryConfig, resolveTimeoutConfig } from './retry-resolver.js';
+export { buildEvaluationContext, evaluateCondition } from './expression/index.js';

package/dist/src/workflow/retry-resolver.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Retry & Timeout Resolution Logic
+ *
+ * Resolves per-template retry and timeout configurations with a layered
+ * override precedence:
+ *
+ *   template-level → phase-level → global escalation config → defaults
+ *
+ * All functions are pure — no side effects.
+ */
+import type { TemplateRetryConfig, TemplateTimeoutConfig, EscalationConfig, EscalationLadderRung } from './workflow-types.js';
+/**
+ * Resolved retry configuration with all values filled in.
+ */
+export interface ResolvedRetryConfig {
+    maxAttempts: number;
+    ladder: EscalationLadderRung[];
+}
+/**
+ * Resolved timeout configuration with duration in milliseconds.
+ */
+export interface ResolvedTimeoutConfig {
+    durationMs: number;
+    action: 'escalate' | 'skip' | 'fail';
+}
+/**
+ * Resolve retry configuration with override precedence:
+ * template-level retry → phase-level retry → global escalation config → defaults
+ *
+ * For each field (maxAttempts, ladder), the first defined value wins:
+ *   1. templateRetry (from branching block)
+ *   2. phaseRetry (from phase definition)
+ *   3. globalEscalation (from workflow definition)
+ *   4. Built-in defaults
+ *
+ * @param templateRetry - Per-template retry config (from branching block)
+ * @param phaseRetry - Per-phase retry config (from phase definition)
+ * @param globalEscalation - Global escalation config (from workflow definition)
+ * @returns Fully resolved retry config with fallback defaults
+ */
+export declare function resolveRetryConfig(templateRetry?: TemplateRetryConfig, phaseRetry?: TemplateRetryConfig, globalEscalation?: EscalationConfig): ResolvedRetryConfig;
+/**
+ * Resolve timeout configuration with override precedence:
+ * template-level timeout → phase-level timeout → null (no timeout)
+ *
+ * @param templateTimeout - Per-template timeout config (from branching block)
+ * @param phaseTimeout - Per-phase timeout config (from phase definition)
+ * @returns Resolved timeout config, or null if no timeout configured
+ */
+export declare function resolveTimeoutConfig(templateTimeout?: TemplateTimeoutConfig, phaseTimeout?: TemplateTimeoutConfig): ResolvedTimeoutConfig | null;
+//# sourceMappingURL=retry-resolver.d.ts.map

package/dist/src/workflow/retry-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-resolver.d.ts","sourceRoot":"","sources":["../../../src/workflow/retry-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,mBAAmB,EACnB,qBAAqB,EACrB,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,qBAAqB,CAAA;AAO5B;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,oBAAoB,EAAE,CAAA;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,UAAU,GAAG,MAAM,GAAG,MAAM,CAAA;CACrC;AAkBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,CAAC,EAAE,mBAAmB,EACnC,UAAU,CAAC,EAAE,mBAAmB,EAChC,gBAAgB,CAAC,EAAE,gBAAgB,GAClC,mBAAmB,CAcrB;AAMD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,eAAe,CAAC,EAAE,qBAAqB,EACvC,YAAY,CAAC,EAAE,qBAAqB,GACnC,qBAAqB,GAAG,IAAI,CAW9B"}

package/dist/src/workflow/retry-resolver.js

@@ -0,0 +1,70 @@
+/**
+ * Retry & Timeout Resolution Logic
+ *
+ * Resolves per-template retry and timeout configurations with a layered
+ * override precedence:
+ *
+ *   template-level → phase-level → global escalation config → defaults
+ *
+ * All functions are pure — no side effects.
+ */
+import { parseDuration } from './duration.js';
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+const DEFAULT_MAX_ATTEMPTS = 3;
+const DEFAULT_LADDER = [
+    { cycle: 1, strategy: 'normal' },
+    { cycle: 2, strategy: 'context-enriched' },
+    { cycle: 3, strategy: 'decompose' },
+];
+// ---------------------------------------------------------------------------
+// Retry Resolution
+// ---------------------------------------------------------------------------
+/**
+ * Resolve retry configuration with override precedence:
+ * template-level retry → phase-level retry → global escalation config → defaults
+ *
+ * For each field (maxAttempts, ladder), the first defined value wins:
+ *   1. templateRetry (from branching block)
+ *   2. phaseRetry (from phase definition)
+ *   3. globalEscalation (from workflow definition)
+ *   4. Built-in defaults
+ *
+ * @param templateRetry - Per-template retry config (from branching block)
+ * @param phaseRetry - Per-phase retry config (from phase definition)
+ * @param globalEscalation - Global escalation config (from workflow definition)
+ * @returns Fully resolved retry config with fallback defaults
+ */
+export function resolveRetryConfig(templateRetry, phaseRetry, globalEscalation) {
+    const maxAttempts = templateRetry?.maxAttempts
+        ?? phaseRetry?.maxAttempts
+        ?? globalEscalation?.circuitBreaker.maxSessionsPerPhase
+        ?? DEFAULT_MAX_ATTEMPTS;
+    const ladder = templateRetry?.ladder
+        ?? phaseRetry?.ladder
+        ?? globalEscalation?.ladder
+        ?? DEFAULT_LADDER;
+    return { maxAttempts, ladder };
+}
+// ---------------------------------------------------------------------------
+// Timeout Resolution
+// ---------------------------------------------------------------------------
+/**
+ * Resolve timeout configuration with override precedence:
+ * template-level timeout → phase-level timeout → null (no timeout)
+ *
+ * @param templateTimeout - Per-template timeout config (from branching block)
+ * @param phaseTimeout - Per-phase timeout config (from phase definition)
+ * @returns Resolved timeout config, or null if no timeout configured
+ */
+export function resolveTimeoutConfig(templateTimeout, phaseTimeout) {
+    const timeout = templateTimeout ?? phaseTimeout;
+    if (!timeout) {
+        return null;
+    }
+    return {
+        durationMs: parseDuration(timeout.duration),
+        action: timeout.action,
+    };
+}

package/dist/src/workflow/retry-resolver.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=retry-resolver.test.d.ts.map

package/dist/src/workflow/retry-resolver.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-resolver.test.d.ts","sourceRoot":"","sources":["../../../src/workflow/retry-resolver.test.ts"],"names":[],"mappings":""}