takt 0.35.4 → 0.37.0

package/dist/core/{piece → workflow}/engine/team-leader-streaming.js

@@ -1,17 +1,17 @@
 import { getLabel } from '../../../shared/i18n/index.js';
-export function buildTeamLeaderParallelLoggerOptions(engineOptions, movementName, movementIteration, subMovementNames, iteration, maxMovements) {
+export function buildTeamLeaderParallelLoggerOptions(engineOptions, stepName, stepIteration, subStepNames, iteration, maxSteps) {
     const options = {
-        subMovementNames,
+        subStepNames,
         parentOnStream: engineOptions.onStream,
-        progressInfo: { iteration, maxMovements },
+        progressInfo: { iteration, maxSteps },
     };
     if (engineOptions.taskPrefix != null && engineOptions.taskColorIndex != null) {
         return {
             ...options,
             taskLabel: engineOptions.taskPrefix,
             taskColorIndex: engineOptions.taskColorIndex,
-            parentMovementName: movementName,
-            movementIteration,
+            parentStepName: stepName,
+            stepIteration,
         };
     }
     return options;
@@ -22,8 +22,8 @@ export function emitTeamLeaderProgressHint(engineOptions, kind) {
         return;
     }
     const key = kind === 'decompose'
-        ? 'piece.teamLeader.decomposeWait'
-        : 'piece.teamLeader.feedbackWait';
+        ? 'workflow.teamLeader.decomposeWait'
+        : 'workflow.teamLeader.feedbackWait';
     const text = `${getLabel(key, engineOptions.language)}\n`;
     onStream({ type: 'text', data: { text } });
 }

package/dist/core/workflow/engine/team-leader-streaming.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"team-leader-streaming.js","sourceRoot":"","sources":["../../../../src/core/workflow/engine/team-leader-streaming.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAIzD,MAAM,UAAU,oCAAoC,CAClD,aAAoC,EACpC,QAAgB,EAChB,aAAqB,EACrB,YAAsB,EACtB,SAAiB,EACjB,QAAgB;IAEhB,MAAM,OAAO,GAA0B;QACrC,YAAY;QACZ,cAAc,EAAE,aAAa,CAAC,QAAQ;QACtC,YAAY,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE;KACtC,CAAC;IAEF,IAAI,aAAa,CAAC,UAAU,IAAI,IAAI,IAAI,aAAa,CAAC,cAAc,IAAI,IAAI,EAAE,CAAC;QAC7E,OAAO;YACL,GAAG,OAAO;YACV,SAAS,EAAE,aAAa,CAAC,UAAU;YACnC,cAAc,EAAE,aAAa,CAAC,cAAc;YAC5C,cAAc,EAAE,QAAQ;YACxB,aAAa;SACd,CAAC;IACJ,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,MAAM,UAAU,0BAA0B,CACxC,aAAoC,EACpC,IAA8B;IAE9B,MAAM,QAAQ,GAAG,aAAa,CAAC,QAAQ,CAAC;IACxC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO;IACT,CAAC;IAED,MAAM,GAAG,GAAG,IAAI,KAAK,WAAW;QAC9B,CAAC,CAAC,mCAAmC;QACrC,CAAC,CAAC,kCAAkC,CAAC;IACvC,MAAM,IAAI,GAAG,GAAG,QAAQ,CAAC,GAAG,EAAE,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC;IAE1D,QAAQ,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;AAC7C,CAAC"}

package/dist/core/workflow/engine/transitions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Workflow state transition logic
+ *
+ * Handles determining the next step based on rules-based routing.
+ */
+import type { WorkflowStep } from '../../models/types.js';
+export interface WorkflowRuleTransition {
+    nextStep?: string;
+    returnValue?: string;
+    requiresUserInput?: boolean;
+}
+export declare function determineRuleTransition(step: WorkflowStep, ruleIndex: number): WorkflowRuleTransition | null;
+/**
+ * Determine next step using rules-based detection.
+ * Returns the next step name from the matched rule, or null if no rule matched.
+ */
+export declare function determineNextStepByRules(step: WorkflowStep, ruleIndex: number): string | null;
+/**
+ * Extract user-facing prompt from blocked response.
+ * Looks for common patterns like "必要な情報:", "質問:", etc.
+ */
+export declare function extractBlockedPrompt(content: string): string;
+//# sourceMappingURL=transitions.d.ts.map

package/dist/core/workflow/engine/transitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transitions.d.ts","sourceRoot":"","sources":["../../../../src/core/workflow/engine/transitions.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,YAAY,EACb,MAAM,uBAAuB,CAAC;AAE/B,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,YAAY,EAClB,SAAS,EAAE,MAAM,GAChB,sBAAsB,GAAG,IAAI,CAW/B;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,YAAY,EAClB,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,IAAI,CAMf;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAkB5D"}

package/dist/core/workflow/engine/transitions.js

@@ -0,0 +1,49 @@
+/**
+ * Workflow state transition logic
+ *
+ * Handles determining the next step based on rules-based routing.
+ */
+export function determineRuleTransition(step, ruleIndex) {
+    const rule = step.rules?.[ruleIndex];
+    if (!rule) {
+        return null;
+    }
+    return {
+        ...(rule.next !== undefined ? { nextStep: rule.next } : {}),
+        ...(rule.returnValue !== undefined ? { returnValue: rule.returnValue } : {}),
+        ...(rule.requiresUserInput === true ? { requiresUserInput: true } : {}),
+    };
+}
+/**
+ * Determine next step using rules-based detection.
+ * Returns the next step name from the matched rule, or null if no rule matched.
+ */
+export function determineNextStepByRules(step, ruleIndex) {
+    const transition = determineRuleTransition(step, ruleIndex);
+    if (!transition) {
+        return null;
+    }
+    return transition.nextStep ?? null;
+}
+/**
+ * Extract user-facing prompt from blocked response.
+ * Looks for common patterns like "必要な情報:", "質問:", etc.
+ */
+export function extractBlockedPrompt(content) {
+    // Try to extract specific question/info needed
+    const patterns = [
+        /必要な情報[:：]\s*(.+?)(?:\n|$)/i,
+        /質問[:：]\s*(.+?)(?:\n|$)/i,
+        /理由[:：]\s*(.+?)(?:\n|$)/i,
+        /確認[:：]\s*(.+?)(?:\n|$)/i,
+    ];
+    for (const pattern of patterns) {
+        const match = content.match(pattern);
+        if (match?.[1]) {
+            return match[1].trim();
+        }
+    }
+    // Return the full content if no specific pattern found
+    return content;
+}
+//# sourceMappingURL=transitions.js.map

package/dist/core/workflow/engine/transitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transitions.js","sourceRoot":"","sources":["../../../../src/core/workflow/engine/transitions.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAYH,MAAM,UAAU,uBAAuB,CACrC,IAAkB,EAClB,SAAiB;IAEjB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,SAAS,CAAC,CAAC;IACrC,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO;QACL,GAAG,CAAC,IAAI,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3D,GAAG,CAAC,IAAI,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC5E,GAAG,CAAC,IAAI,CAAC,iBAAiB,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,iBAAiB,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACxE,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,wBAAwB,CACtC,IAAkB,EAClB,SAAiB;IAEjB,MAAM,UAAU,GAAG,uBAAuB,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IAC5D,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,UAAU,CAAC,QAAQ,IAAI,IAAI,CAAC;AACrC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAAC,OAAe;IAClD,+CAA+C;IAC/C,MAAM,QAAQ,GAAG;QACf,4BAA4B;QAC5B,yBAAyB;QACzB,yBAAyB;QACzB,yBAAyB;KAC1B,CAAC;IAEF,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACrC,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACf,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QACzB,CAAC;IACH,CAAC;IAED,uDAAuD;IACvD,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/core/workflow/evaluation/AggregateEvaluator.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Aggregate condition evaluator for parallel workflow steps
+ *
+ * Evaluates all()/any() aggregate conditions against sub-step results.
+ */
+import type { WorkflowStep, WorkflowState } from '../../models/types.js';
+/**
+ * Evaluates aggregate conditions (all()/any()) for parallel parent steps.
+ *
+ * For each aggregate rule, checks the matched condition text of sub-steps:
+ * - all("X"): true when ALL sub-steps have matched condition === X
+ * - all("A", "B"): true when 1st sub-step matches "A" AND 2nd sub-step matches "B" (order-based)
+ * - any("X"): true when at least ONE sub-step has matched condition === X
+ * - any("A", "B"): true when at least ONE sub-step matches "A" OR "B"
+ *
+ * Edge cases per spec:
+ * - Sub-step with no matched rule: all() → false, any() → skip that sub-step
+ * - No sub-steps (0 件): both → false
+ * - Non-parallel step: both → false
+ * - all("A", "B") with wrong number of sub-steps: false (logged as error)
+ */
+export declare class AggregateEvaluator {
+    private readonly step;
+    private readonly state;
+    constructor(step: WorkflowStep, state: WorkflowState);
+    /**
+     * Evaluate aggregate conditions.
+     * Returns the 0-based rule index in the step's rules array, or -1 if no match.
+     */
+    evaluate(): number;
+}
+//# sourceMappingURL=AggregateEvaluator.d.ts.map

package/dist/core/workflow/evaluation/AggregateEvaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AggregateEvaluator.d.ts","sourceRoot":"","sources":["../../../../src/core/workflow/evaluation/AggregateEvaluator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAKzE;;;;;;;;;;;;;;GAcG;AACH,qBAAa,kBAAkB;IAE3B,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,KAAK;gBADL,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,aAAa;IAGvC;;;OAGG;IACH,QAAQ,IAAI,MAAM;CAiFnB"}

package/dist/core/{piece → workflow}/evaluation/AggregateEvaluator.js

@@ -1,24 +1,24 @@
 /**
- * Aggregate condition evaluator for parallel piece movements
+ * Aggregate condition evaluator for parallel workflow steps
  *
- * Evaluates all()/any() aggregate conditions against sub-movement results.
+ * Evaluates all()/any() aggregate conditions against sub-step results.
  */
 import { createLogger } from '../../../shared/utils/index.js';
 const log = createLogger('aggregate-evaluator');
 /**
- * Evaluates aggregate conditions (all()/any()) for parallel parent movements.
+ * Evaluates aggregate conditions (all()/any()) for parallel parent steps.
  *
- * For each aggregate rule, checks the matched condition text of sub-movements:
- * - all("X"): true when ALL sub-movements have matched condition === X
- * - all("A", "B"): true when 1st sub-movement matches "A" AND 2nd sub-movement matches "B" (order-based)
- * - any("X"): true when at least ONE sub-movement has matched condition === X
- * - any("A", "B"): true when at least ONE sub-movement matches "A" OR "B"
+ * For each aggregate rule, checks the matched condition text of sub-steps:
+ * - all("X"): true when ALL sub-steps have matched condition === X
+ * - all("A", "B"): true when 1st sub-step matches "A" AND 2nd sub-step matches "B" (order-based)
+ * - any("X"): true when at least ONE sub-step has matched condition === X
+ * - any("A", "B"): true when at least ONE sub-step matches "A" OR "B"
  *
  * Edge cases per spec:
- * - Sub-movement with no matched rule: all() → false, any() → skip that sub-movement
- * - No sub-movements (0 件): both → false
- * - Non-parallel movement: both → false
- * - all("A", "B") with wrong number of sub-movements: false (logged as error)
+ * - Sub-step with no matched rule: all() → false, any() → skip that sub-step
+ * - No sub-steps (0 件): both → false
+ * - Non-parallel step: both → false
+ * - all("A", "B") with wrong number of sub-steps: false (logged as error)
  */
 export class AggregateEvaluator {
     step;
@@ -29,7 +29,7 @@ export class AggregateEvaluator {
     }
     /**
      * Evaluate aggregate conditions.
-     * Returns the 0-based rule index in the movement's rules array, or -1 if no match.
+     * Returns the 0-based rule index in the step's rules array, or -1 if no match.
      */
     evaluate() {
         if (!this.step.rules || !this.step.parallel || this.step.parallel.length === 0)
@@ -41,21 +41,21 @@ export class AggregateEvaluator {
             if (!rule.isAggregateCondition || !rule.aggregateType || !rule.aggregateConditionText) {
                 continue;
             }
-            const subMovements = this.step.parallel;
+            const subSteps = this.step.parallel;
             const targetCondition = rule.aggregateConditionText;
             if (rule.aggregateType === 'all') {
-                // Multiple conditions: order-based matching (1st sub-movement matches 1st condition, etc.)
+                // Multiple conditions: order-based matching (1st sub-step matches 1st condition, etc.)
                 if (Array.isArray(targetCondition)) {
-                    if (targetCondition.length !== subMovements.length) {
+                    if (targetCondition.length !== subSteps.length) {
                         log.error('all() condition count mismatch', {
-                            movement: this.step.name,
+                            step: this.step.name,
                             conditionCount: targetCondition.length,
-                            subMovementCount: subMovements.length,
+                            subStepCount: subSteps.length,
                         });
                         continue;
                     }
-                    const allMatch = subMovements.every((sub, idx) => {
-                        const output = this.state.movementOutputs.get(sub.name);
+                    const allMatch = subSteps.every((sub, idx) => {
+                        const output = this.state.stepOutputs.get(sub.name);
                         if (!output || output.matchedRuleIndex == null || !sub.rules)
                             return false;
                         const matchedRule = sub.rules[output.matchedRuleIndex];
@@ -65,21 +65,21 @@ export class AggregateEvaluator {
                         return matchedRule?.condition === expectedCondition;
                     });
                     if (allMatch) {
-                        log.debug('Aggregate all() matched (multi-condition)', { movement: this.step.name, conditions: targetCondition, ruleIndex: i });
+                        log.debug('Aggregate all() matched (multi-condition)', { step: this.step.name, conditions: targetCondition, ruleIndex: i });
                         return i;
                     }
                 }
                 else {
-                    // Single condition: all sub-movements must match the same condition
-                    const allMatch = subMovements.every((sub) => {
-                        const output = this.state.movementOutputs.get(sub.name);
+                    // Single condition: all sub-steps must match the same condition
+                    const allMatch = subSteps.every((sub) => {
+                        const output = this.state.stepOutputs.get(sub.name);
                         if (!output || output.matchedRuleIndex == null || !sub.rules)
                             return false;
                         const matchedRule = sub.rules[output.matchedRuleIndex];
                         return matchedRule?.condition === targetCondition;
                     });
                     if (allMatch) {
-                        log.debug('Aggregate all() matched', { movement: this.step.name, condition: targetCondition, ruleIndex: i });
+                        log.debug('Aggregate all() matched', { step: this.step.name, condition: targetCondition, ruleIndex: i });
                         return i;
                     }
                 }
@@ -87,30 +87,30 @@ export class AggregateEvaluator {
             else {
                 // 'any'
                 if (Array.isArray(targetCondition)) {
-                    // Multiple conditions: at least one sub-movement matches at least one condition
-                    const anyMatch = subMovements.some((sub) => {
-                        const output = this.state.movementOutputs.get(sub.name);
+                    // Multiple conditions: at least one sub-step matches at least one condition
+                    const anyMatch = subSteps.some((sub) => {
+                        const output = this.state.stepOutputs.get(sub.name);
                         if (!output || output.matchedRuleIndex == null || !sub.rules)
                             return false;
                         const matchedRule = sub.rules[output.matchedRuleIndex];
                         return targetCondition.includes(matchedRule?.condition ?? '');
                     });
                     if (anyMatch) {
-                        log.debug('Aggregate any() matched (multi-condition)', { movement: this.step.name, conditions: targetCondition, ruleIndex: i });
+                        log.debug('Aggregate any() matched (multi-condition)', { step: this.step.name, conditions: targetCondition, ruleIndex: i });
                         return i;
                     }
                 }
                 else {
-                    // Single condition: at least one sub-movement matches the condition
-                    const anyMatch = subMovements.some((sub) => {
-                        const output = this.state.movementOutputs.get(sub.name);
+                    // Single condition: at least one sub-step matches the condition
+                    const anyMatch = subSteps.some((sub) => {
+                        const output = this.state.stepOutputs.get(sub.name);
                         if (!output || output.matchedRuleIndex == null || !sub.rules)
                             return false;
                         const matchedRule = sub.rules[output.matchedRuleIndex];
                         return matchedRule?.condition === targetCondition;
                     });
                     if (anyMatch) {
-                        log.debug('Aggregate any() matched', { movement: this.step.name, condition: targetCondition, ruleIndex: i });
+                        log.debug('Aggregate any() matched', { step: this.step.name, condition: targetCondition, ruleIndex: i });
                         return i;
                     }
                 }

package/dist/core/workflow/evaluation/AggregateEvaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AggregateEvaluator.js","sourceRoot":"","sources":["../../../../src/core/workflow/evaluation/AggregateEvaluator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAE9D,MAAM,GAAG,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAC;AAEhD;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,kBAAkB;IAEV;IACA;IAFnB,YACmB,IAAkB,EAClB,KAAoB;QADpB,SAAI,GAAJ,IAAI,CAAc;QAClB,UAAK,GAAL,KAAK,CAAe;IACpC,CAAC;IAEJ;;;OAGG;IACH,QAAQ;QACN,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,CAAC,CAAC,CAAC;QAE1F,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAChD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAChC,IAAI,CAAC,IAAI;gBAAE,SAAS;YACpB,IAAI,CAAC,IAAI,CAAC,oBAAoB,IAAI,CAAC,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,sBAAsB,EAAE,CAAC;gBACtF,SAAS;YACX,CAAC;YAED,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;YACpC,MAAM,eAAe,GAAG,IAAI,CAAC,sBAAsB,CAAC;YAEpD,IAAI,IAAI,CAAC,aAAa,KAAK,KAAK,EAAE,CAAC;gBACjC,uFAAuF;gBACvF,IAAI,KAAK,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE,CAAC;oBACnC,IAAI,eAAe,CAAC,MAAM,KAAK,QAAQ,CAAC,MAAM,EAAE,CAAC;wBAC/C,GAAG,CAAC,KAAK,CAAC,gCAAgC,EAAE;4BAC1C,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI;4BACpB,cAAc,EAAE,eAAe,CAAC,MAAM;4BACtC,YAAY,EAAE,QAAQ,CAAC,MAAM;yBAC9B,CAAC,CAAC;wBACH,SAAS;oBACX,CAAC;oBACD,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;wBAC3C,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;wBACpD,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,gBAAgB,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK;4BAAE,OAAO,KAAK,CAAC;wBAC3E,MAAM,WAAW,GAAG,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;wBACvD,MAAM,iBAAiB,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC;wBAC/C,IAAI,CAAC,iBAAiB;4BAAE,OAAO,KAAK,CAAC;wBACrC,OAAO,WAAW,EAAE,SAAS,KAAK,iBAAiB,CAAC;oBACtD,CAAC,CAAC,CAAC;oBACH,IAAI,QAAQ,EAAE,CAAC;wBACb,GAAG,CAAC,KAAK,CAAC,2CAA2C,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,eAAe,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC;wBAC5H,OAAO,CAAC,CAAC;oBACX,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,gEAAgE;oBAChE,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;wBACtC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;wBACpD,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,gBAAgB,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK;4BAAE,OAAO,KAAK,CAAC;wBAC3E,MAAM,WAAW,GAAG,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;wBACvD,OAAO,WAAW,EAAE,SAAS,KAAK,eAAe,CAAC;oBACpD,CAAC,CAAC,CAAC;oBACH,IAAI,QAAQ,EAAE,CAAC;wBACb,GAAG,CAAC,KAAK,CAAC,yBAAyB,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,eAAe,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC;wBACzG,OAAO,CAAC,CAAC;oBACX,CAAC;gBACH,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,QAAQ;gBACR,IAAI,KAAK,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE,CAAC;oBACnC,4EAA4E;oBAC5E,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE;wBACrC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;wBACpD,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,gBAAgB,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK;4BAAE,OAAO,KAAK,CAAC;wBAC3E,MAAM,WAAW,GAAG,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;wBACvD,OAAO,eAAe,CAAC,QAAQ,CAAC,WAAW,EAAE,SAAS,IAAI,EAAE,CAAC,CAAC;oBAChE,CAAC,CAAC,CAAC;oBACH,IAAI,QAAQ,EAAE,CAAC;wBACb,GAAG,CAAC,KAAK,CAAC,2CAA2C,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,eAAe,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC;wBAC5H,OAAO,CAAC,CAAC;oBACX,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,gEAAgE;oBAChE,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE;wBACrC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;wBACpD,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,gBAAgB,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK;4BAAE,OAAO,KAAK,CAAC;wBAC3E,MAAM,WAAW,GAAG,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;wBACvD,OAAO,WAAW,EAAE,SAAS,KAAK,eAAe,CAAC;oBACpD,CAAC,CAAC,CAAC;oBACH,IAAI,QAAQ,EAAE,CAAC;wBACb,GAAG,CAAC,KAAK,CAAC,yBAAyB,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,eAAe,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC;wBACzG,OAAO,CAAC,CAAC;oBACX,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,CAAC,CAAC,CAAC;IACZ,CAAC;CACF"}

package/dist/core/{piece → workflow}/evaluation/RuleEvaluator.d.ts

@@ -1,11 +1,11 @@
 /**
- * Rule evaluation logic for piece movements
+ * Rule evaluation logic for workflow steps
  *
- * Evaluates piece movement rules to determine the matched rule index.
+ * Evaluates workflow step rules to determine the matched rule index.
  * Supports tag-based detection, ai() conditions, aggregate conditions,
  * and AI judge fallback.
  */
-import type { PieceMovement, PieceState, RuleMatchMethod } from '../../models/types.js';
+import type { WorkflowStep, WorkflowState, RuleMatchMethod } from '../../models/types.js';
 import type { StructuredCaller } from '../../../agents/structured-caller.js';
 import type { ProviderType, RuleIndexDetector } from '../types.js';
 export interface RuleMatch {
@@ -13,11 +13,11 @@ export interface RuleMatch {
     method: RuleMatchMethod;
 }
 export interface RuleEvaluatorContext {
-    /** Piece state (for accessing movementOutputs in aggregate evaluation) */
-    state: PieceState;
+    /** Workflow state (for accessing stepOutputs in aggregate evaluation) */
+    state: WorkflowState;
     /** Working directory (for AI judge calls) */
     cwd: string;
-    /** Effective provider for the movement */
+    /** Effective provider for the step */
     provider?: ProviderType;
     resolvedProvider?: ProviderType;
     resolvedModel?: string;
@@ -29,24 +29,33 @@ export interface RuleEvaluatorContext {
     structuredCaller: StructuredCaller;
 }
 /**
- * Evaluates rules for a piece movement to determine the next transition.
+ * Evaluates rules for a workflow step to determine the next transition.
  *
  * Evaluation order (first match wins):
- * 1. Aggregate conditions: all()/any() — evaluate sub-movement results
- * 2. Tag detection from Phase 3 output
- * 3. Tag detection from Phase 1 output (fallback)
- * 4. ai() condition evaluation via AI judge
- * 5. All-conditions AI judge (final fallback)
+ * 1. Aggregate conditions: all()/any() — evaluate sub-step results
+ * 2. Immediate deterministic when conditions that appear before the matched Phase 3 tag
+ * 3. Tag detection from Phase 3 output
+ * 4. Immediate deterministic when conditions that appear before the matched Phase 1 tag
+ * 5. Tag detection from Phase 1 output (fallback)
+ * 6. Immediate deterministic when conditions that appear before the matched ai() rule
+ * 7. ai() condition evaluation via AI judge
+ * 8. Remaining immediate deterministic when conditions
+ * 9. All-conditions AI judge (final fallback)
+ * 10. Deferred deterministic fallbacks (for example when: true)
  *
- * Returns undefined for movements without rules.
+ * Returns undefined for steps without rules.
  * Throws if rules exist but no rule matched (Fail Fast).
  */
 export declare class RuleEvaluator {
     private readonly step;
     private readonly ctx;
-    constructor(step: PieceMovement, ctx: RuleEvaluatorContext);
+    constructor(step: WorkflowStep, ctx: RuleEvaluatorContext);
     private structuredCallerJudgeOptions;
     evaluate(agentContent: string, tagContent: string): Promise<RuleMatch | undefined>;
+    private resolveTaggedRuleIndex;
+    private findFirstNonDeterministicRuleIndex;
+    private evaluateImmediateDeterministicConditions;
+    private evaluateDeferredDeterministicConditions;
     /**
      * Evaluate ai() conditions via AI judge.
      * Returns the 0-based rule index, or -1 if no match.

package/dist/core/workflow/evaluation/RuleEvaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleEvaluator.d.ts","sourceRoot":"","sources":["../../../../src/core/workflow/evaluation/RuleEvaluator.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,eAAe,EAChB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAC7E,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AASnE,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,eAAe,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACnC,yEAAyE;IACzE,KAAK,EAAE,aAAa,CAAC;IACrB,6CAA6C;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,sCAAsC;IACtC,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,gBAAgB,CAAC,EAAE,YAAY,CAAC;IAChC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iDAAiD;IACjD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,8BAA8B;IAC9B,eAAe,EAAE,iBAAiB,CAAC;IACnC,wBAAwB;IACxB,gBAAgB,EAAE,gBAAgB,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,aAAa;IAEtB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG;gBADH,IAAI,EAAE,YAAY,EAClB,GAAG,EAAE,oBAAoB;IAG5C,OAAO,CAAC,4BAA4B;IAY9B,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IA4ExF,OAAO,CAAC,sBAAsB;IAgB9B,OAAO,CAAC,kCAAkC;IAoB1C,OAAO,CAAC,wCAAwC;IA2BhD,OAAO,CAAC,uCAAuC;IAsB/C;;;OAGG;YACW,oBAAoB;IA0ClC;;;OAGG;YACW,+BAA+B;CAuC9C"}

package/dist/core/workflow/evaluation/RuleEvaluator.js

@@ -0,0 +1,252 @@
+/**
+ * Rule evaluation logic for workflow steps
+ *
+ * Evaluates workflow step rules to determine the matched rule index.
+ * Supports tag-based detection, ai() conditions, aggregate conditions,
+ * and AI judge fallback.
+ */
+import { createLogger } from '../../../shared/utils/index.js';
+import { buildJudgeConditions } from '../../../agents/judge-utils.js';
+import { AggregateEvaluator } from './AggregateEvaluator.js';
+import { evaluateWhenExpression } from './when-evaluator.js';
+import { isDeferredDeterministicCondition, isDeterministicCondition } from './rule-utils.js';
+const log = createLogger('rule-evaluator');
+/**
+ * Evaluates rules for a workflow step to determine the next transition.
+ *
+ * Evaluation order (first match wins):
+ * 1. Aggregate conditions: all()/any() — evaluate sub-step results
+ * 2. Immediate deterministic when conditions that appear before the matched Phase 3 tag
+ * 3. Tag detection from Phase 3 output
+ * 4. Immediate deterministic when conditions that appear before the matched Phase 1 tag
+ * 5. Tag detection from Phase 1 output (fallback)
+ * 6. Immediate deterministic when conditions that appear before the matched ai() rule
+ * 7. ai() condition evaluation via AI judge
+ * 8. Remaining immediate deterministic when conditions
+ * 9. All-conditions AI judge (final fallback)
+ * 10. Deferred deterministic fallbacks (for example when: true)
+ *
+ * Returns undefined for steps without rules.
+ * Throws if rules exist but no rule matched (Fail Fast).
+ */
+export class RuleEvaluator {
+    step;
+    ctx;
+    constructor(step, ctx) {
+        this.step = step;
+        this.ctx = ctx;
+    }
+    structuredCallerJudgeOptions() {
+        return {
+            cwd: this.ctx.cwd,
+            provider: this.ctx.provider,
+            resolvedProvider: this.ctx.resolvedProvider,
+            resolvedModel: this.ctx.resolvedModel,
+        };
+    }
+    async evaluate(agentContent, tagContent) {
+        if (!this.step.rules || this.step.rules.length === 0)
+            return undefined;
+        const interactiveEnabled = this.ctx.interactive === true;
+        // 1. Aggregate conditions (all/any) — only meaningful for parallel parent steps
+        const aggEvaluator = new AggregateEvaluator(this.step, this.ctx.state);
+        const aggIndex = aggEvaluator.evaluate();
+        if (aggIndex >= 0) {
+            return { index: aggIndex, method: 'aggregate' };
+        }
+        const firstNonDeterministicIndex = this.findFirstNonDeterministicRuleIndex();
+        const leadingDeterministicIndex = this.evaluateImmediateDeterministicConditions(0, firstNonDeterministicIndex >= 0 ? firstNonDeterministicIndex : undefined);
+        if (leadingDeterministicIndex >= 0) {
+            return { index: leadingDeterministicIndex, method: 'auto_select' };
+        }
+        const phase3TagIndex = this.resolveTaggedRuleIndex(tagContent, interactiveEnabled);
+        if (phase3TagIndex >= 0) {
+            const immediateDeterministicIndex = this.evaluateImmediateDeterministicConditions(firstNonDeterministicIndex + 1, phase3TagIndex);
+            if (immediateDeterministicIndex >= 0) {
+                return { index: immediateDeterministicIndex, method: 'auto_select' };
+            }
+            return { index: phase3TagIndex, method: 'phase3_tag' };
+        }
+        const phase1TagIndex = this.resolveTaggedRuleIndex(agentContent, interactiveEnabled);
+        if (phase1TagIndex >= 0) {
+            const immediateDeterministicIndex = this.evaluateImmediateDeterministicConditions(firstNonDeterministicIndex + 1, phase1TagIndex);
+            if (immediateDeterministicIndex >= 0) {
+                return { index: immediateDeterministicIndex, method: 'auto_select' };
+            }
+            return { index: phase1TagIndex, method: 'phase1_tag' };
+        }
+        const aiRuleIndex = await this.evaluateAiConditions(agentContent);
+        if (aiRuleIndex >= 0) {
+            const immediateDeterministicIndex = this.evaluateImmediateDeterministicConditions(firstNonDeterministicIndex + 1, aiRuleIndex);
+            if (immediateDeterministicIndex >= 0) {
+                return { index: immediateDeterministicIndex, method: 'auto_select' };
+            }
+            return { index: aiRuleIndex, method: 'ai_judge' };
+        }
+        const immediateDeterministicIndex = this.evaluateImmediateDeterministicConditions(firstNonDeterministicIndex + 1);
+        if (immediateDeterministicIndex >= 0) {
+            return { index: immediateDeterministicIndex, method: 'auto_select' };
+        }
+        const fallbackIndex = await this.evaluateAllConditionsViaAiJudge(agentContent);
+        if (fallbackIndex >= 0) {
+            return { index: fallbackIndex, method: 'ai_judge_fallback' };
+        }
+        const deferredDeterministicIndex = this.evaluateDeferredDeterministicConditions();
+        if (deferredDeterministicIndex >= 0) {
+            return { index: deferredDeterministicIndex, method: 'auto_select' };
+        }
+        throw new Error(`Status not found for step "${this.step.name}": no rule matched after all detection phases`);
+    }
+    resolveTaggedRuleIndex(content, interactiveEnabled) {
+        if (!content || !this.step.rules)
+            return -1;
+        const ruleIndex = this.ctx.detectRuleIndex(content, this.step.name);
+        if (ruleIndex < 0 || ruleIndex >= this.step.rules.length) {
+            return -1;
+        }
+        const rule = this.step.rules[ruleIndex];
+        if (rule?.interactiveOnly && !interactiveEnabled) {
+            return -1;
+        }
+        return ruleIndex;
+    }
+    findFirstNonDeterministicRuleIndex() {
+        if (!this.step.rules)
+            return -1;
+        for (let i = 0; i < this.step.rules.length; i++) {
+            const rule = this.step.rules[i];
+            if (!rule)
+                continue;
+            if (rule.interactiveOnly && this.ctx.interactive !== true) {
+                continue;
+            }
+            if (rule.isAggregateCondition) {
+                continue;
+            }
+            if (!isDeterministicCondition(rule.condition)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    evaluateImmediateDeterministicConditions(startIndex = 0, endExclusive) {
+        if (!this.step.rules)
+            return -1;
+        const upperBound = endExclusive ?? this.step.rules.length;
+        for (let i = Math.max(startIndex, 0); i < upperBound; i++) {
+            const rule = this.step.rules[i];
+            if (!rule)
+                continue;
+            if (rule.interactiveOnly && this.ctx.interactive !== true) {
+                continue;
+            }
+            if (rule.isAiCondition || rule.isAggregateCondition) {
+                continue;
+            }
+            if (!isDeterministicCondition(rule.condition)) {
+                continue;
+            }
+            if (isDeferredDeterministicCondition(rule.condition)) {
+                continue;
+            }
+            if (evaluateWhenExpression(rule.condition, this.ctx.state)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    evaluateDeferredDeterministicConditions() {
+        if (!this.step.rules)
+            return -1;
+        for (let i = 0; i < this.step.rules.length; i++) {
+            const rule = this.step.rules[i];
+            if (!rule)
+                continue;
+            if (rule.interactiveOnly && this.ctx.interactive !== true) {
+                continue;
+            }
+            if (rule.isAiCondition || rule.isAggregateCondition) {
+                continue;
+            }
+            if (!isDeterministicCondition(rule.condition) || !isDeferredDeterministicCondition(rule.condition)) {
+                continue;
+            }
+            if (evaluateWhenExpression(rule.condition, this.ctx.state)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    /**
+     * Evaluate ai() conditions via AI judge.
+     * Returns the 0-based rule index, or -1 if no match.
+     */
+    async evaluateAiConditions(agentOutput) {
+        if (!this.step.rules)
+            return -1;
+        const aiConditions = [];
+        for (let i = 0; i < this.step.rules.length; i++) {
+            const rule = this.step.rules[i];
+            if (!rule)
+                continue;
+            if (rule.interactiveOnly && this.ctx.interactive !== true) {
+                continue;
+            }
+            if (rule.isAiCondition && rule.aiConditionText) {
+                aiConditions.push({ index: i, text: rule.aiConditionText });
+            }
+        }
+        if (aiConditions.length === 0)
+            return -1;
+        log.debug('Evaluating ai() conditions via judge', {
+            step: this.step.name,
+            conditionCount: aiConditions.length,
+        });
+        const judgeResult = await this.ctx.structuredCaller.evaluateCondition(agentOutput, aiConditions, this.structuredCallerJudgeOptions());
+        const matched = aiConditions.find((condition) => condition.index === judgeResult);
+        if (matched) {
+            log.debug('AI judge matched condition', {
+                step: this.step.name,
+                judgeResult,
+                originalRuleIndex: matched.index,
+                condition: matched.text,
+            });
+            return judgeResult;
+        }
+        log.debug('AI judge did not match any condition', { step: this.step.name });
+        return -1;
+    }
+    /**
+     * Final fallback: evaluate ALL rule conditions via AI judge.
+     * Returns the 0-based rule index, or -1 if no match.
+     */
+    async evaluateAllConditionsViaAiJudge(agentOutput) {
+        if (!this.step.rules || this.step.rules.length === 0)
+            return -1;
+        const judgeableRules = this.step.rules
+            .map((rule, index) => ({ rule, index }))
+            .filter(({ rule }) => !rule.isAggregateCondition && !isDeterministicCondition(rule.condition))
+            .filter(({ rule }) => this.ctx.interactive === true || !rule.interactiveOnly);
+        const conditions = buildJudgeConditions(judgeableRules.map(({ rule }) => rule), true, judgeableRules.map(({ index }) => index));
+        if (conditions.length === 0) {
+            return -1;
+        }
+        log.debug('Evaluating all conditions via AI judge (final fallback)', {
+            step: this.step.name,
+            conditionCount: conditions.length,
+        });
+        const judgeResult = await this.ctx.structuredCaller.evaluateCondition(agentOutput, conditions, this.structuredCallerJudgeOptions());
+        const matched = conditions.find((condition) => condition.index === judgeResult);
+        if (matched) {
+            log.debug('AI judge (fallback) matched condition', {
+                step: this.step.name,
+                ruleIndex: judgeResult,
+                condition: matched.text,
+            });
+            return judgeResult;
+        }
+        log.debug('AI judge (fallback) did not match any condition', { step: this.step.name });
+        return -1;
+    }
+}
+//# sourceMappingURL=RuleEvaluator.js.map