edsger 0.41.3 → 0.42.1

package/dist/phases/pr-splitting/context.js

@@ -53,18 +53,18 @@ function getChangedFiles(baseRef, headRef) {
 /**
  * Determine the diff base ref for incremental re-runs
  * If existing PRs have last_synced_commit, use the earliest one
- * Otherwise use main
+ * Otherwise use origin/main (remote-tracking ref, always up-to-date after fetch)
  */
 function determineDiffBaseRef(existingPRs, replaceExisting) {
     if (replaceExisting || existingPRs.length === 0) {
-        return 'main';
+        return 'origin/main';
     }
     // Find the minimum last_synced_commit (earliest sync point)
     const syncedCommits = existingPRs
         .map((pr) => pr.last_synced_commit)
         .filter((c) => c !== null);
     if (syncedCommits.length === 0) {
-        return 'main';
+        return 'origin/main';
     }
     // All PRs should have been synced to the same commit
     // Use the first one (they should all be equal after a successful sync)
@@ -87,6 +87,22 @@ export async function fetchPRSplittingContext(featureId, verbose, replaceExistin
             getPullRequests({ featureId, verbose }).catch(() => []),
             getGitHubConfig(featureId, verbose),
         ]);
+        // Fetch latest remote refs (updates origin/main and all remote-tracking branches)
+        try {
+            const credArgs = buildCredentialArgs(githubConfig.token);
+            execFileSync('git', [...credArgs, 'fetch', 'origin'], {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
+            if (verbose) {
+                logInfo('✅ Fetched latest remote refs');
+            }
+        }
+        catch (error) {
+            if (verbose) {
+                logInfo(`⚠️  Could not fetch from origin: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
         // Verify dev branch exists
         const localExists = branchExists(devBranchName);
         const remoteExists = !localExists && remoteBranchExists(devBranchName, githubConfig.token);
@@ -94,17 +110,6 @@ export async function fetchPRSplittingContext(featureId, verbose, replaceExistin
             throw new Error(`Development branch '${devBranchName}' does not exist. ` +
                 `The feature must have code on the dev branch before PR splitting.`);
         }
-        // If branch only exists on remote, fetch it (using credential helper)
-        if (!localExists && remoteExists) {
-            if (verbose) {
-                logInfo(`Fetching remote branch ${devBranchName}...`);
-            }
-            const credArgs = buildCredentialArgs(githubConfig.token);
-            execFileSync('git', [...credArgs, 'fetch', 'origin', devBranchName], {
-                encoding: 'utf-8',
-                stdio: 'pipe',
-            });
-        }
         const product = await getProduct(feature.product_id, verbose);
         // Detect fork status
         let forkInfo = { isFork: false };
@@ -131,7 +136,7 @@ export async function fetchPRSplittingContext(featureId, verbose, replaceExistin
         const baseRef = determineDiffBaseRef(existingPullRequests, replaceExisting);
         const devBranchHeadSha = getBranchHeadSha(devRef);
         // Check if there are new changes since last sync
-        if (baseRef !== 'main' && baseRef === devBranchHeadSha) {
+        if (baseRef !== 'origin/main' && baseRef === devBranchHeadSha) {
             if (verbose) {
                 logInfo(`No new changes since last sync (HEAD: ${devBranchHeadSha})`);
             }

package/dist/services/lifecycle-agent/__tests__/phase-criteria.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for phase quality criteria definitions
+ */
+export {};

package/dist/services/lifecycle-agent/__tests__/phase-criteria.test.js

@@ -0,0 +1,133 @@
+/**
+ * Unit tests for phase quality criteria definitions
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { DEFAULT_PHASE_CRITERIA, USER_STORIES_ANALYSIS_CRITERIA, TEST_CASES_ANALYSIS_CRITERIA, TECHNICAL_DESIGN_CRITERIA, BRANCH_PLANNING_CRITERIA, CODE_IMPLEMENTATION_CRITERIA, FUNCTIONAL_TESTING_CRITERIA, CODE_REVIEW_CRITERIA, getPhaseQualityCriteria, } from '../phase-criteria.js';
+describe('Phase Quality Criteria', () => {
+    describe('DEFAULT_PHASE_CRITERIA', () => {
+        it('should cover all evaluable phases', () => {
+            const expectedPhases = [
+                'user_stories_analysis',
+                'test_cases_analysis',
+                'technical_design',
+                'branch_planning',
+                'code_implementation',
+                'functional_testing',
+                'code_review',
+            ];
+            for (const phase of expectedPhases) {
+                assert.ok(phase in DEFAULT_PHASE_CRITERIA, `Should have criteria for phase: ${phase}`);
+            }
+        });
+        it('should have consistent phase names in criteria objects', () => {
+            for (const [key, criteria] of Object.entries(DEFAULT_PHASE_CRITERIA)) {
+                assert.strictEqual(criteria.phase, key, `Criteria for ${key} should have matching phase name`);
+            }
+        });
+    });
+    describe('Criteria Structural Validity', () => {
+        const allCriteria = [
+            USER_STORIES_ANALYSIS_CRITERIA,
+            TEST_CASES_ANALYSIS_CRITERIA,
+            TECHNICAL_DESIGN_CRITERIA,
+            BRANCH_PLANNING_CRITERIA,
+            CODE_IMPLEMENTATION_CRITERIA,
+            FUNCTIONAL_TESTING_CRITERIA,
+            CODE_REVIEW_CRITERIA,
+        ];
+        for (const phaseCriteria of allCriteria) {
+            describe(phaseCriteria.phase, () => {
+                it('should have advanceThreshold > escalateThreshold', () => {
+                    assert.ok(phaseCriteria.advanceThreshold > phaseCriteria.escalateThreshold, `advanceThreshold (${phaseCriteria.advanceThreshold}) should be > escalateThreshold (${phaseCriteria.escalateThreshold})`);
+                });
+                it('should have thresholds in valid range (0-100)', () => {
+                    assert.ok(phaseCriteria.advanceThreshold >= 0);
+                    assert.ok(phaseCriteria.advanceThreshold <= 100);
+                    assert.ok(phaseCriteria.escalateThreshold >= 0);
+                    assert.ok(phaseCriteria.escalateThreshold <= 100);
+                });
+                it('should have maxAutoRetries >= 1', () => {
+                    assert.ok(phaseCriteria.maxAutoRetries >= 1, `maxAutoRetries should be >= 1, got ${phaseCriteria.maxAutoRetries}`);
+                });
+                it('should have at least one criterion', () => {
+                    assert.ok(phaseCriteria.criteria.length > 0, 'Should have at least one criterion');
+                });
+                it('should have criteria weights that approximately sum to 1', () => {
+                    const totalWeight = phaseCriteria.criteria.reduce((sum, c) => sum + c.weight, 0);
+                    assert.ok(Math.abs(totalWeight - 1.0) < 0.01, `Weights should sum to ~1.0, got ${totalWeight}`);
+                });
+                it('should have unique criterion IDs', () => {
+                    const ids = phaseCriteria.criteria.map((c) => c.id);
+                    const uniqueIds = new Set(ids);
+                    assert.strictEqual(ids.length, uniqueIds.size, 'Criterion IDs should be unique');
+                });
+                it('should have valid criterion weights (0 < weight <= 1)', () => {
+                    for (const criterion of phaseCriteria.criteria) {
+                        assert.ok(criterion.weight > 0 && criterion.weight <= 1, `Weight for ${criterion.id} should be between 0 and 1, got ${criterion.weight}`);
+                    }
+                });
+                it('should have valid minimum scores (0-100)', () => {
+                    for (const criterion of phaseCriteria.criteria) {
+                        assert.ok(criterion.minimumScore >= 0 && criterion.minimumScore <= 100, `minimumScore for ${criterion.id} should be 0-100, got ${criterion.minimumScore}`);
+                    }
+                });
+                it('should have non-empty evaluation guidance', () => {
+                    for (const criterion of phaseCriteria.criteria) {
+                        assert.ok(criterion.evaluationGuidance.length > 0, `Criterion ${criterion.id} should have evaluation guidance`);
+                    }
+                });
+            });
+        }
+    });
+    describe('getPhaseQualityCriteria', () => {
+        it('should return default criteria for known phases', () => {
+            const criteria = getPhaseQualityCriteria('user_stories_analysis');
+            assert.ok(criteria);
+            assert.strictEqual(criteria.phase, 'user_stories_analysis');
+            assert.strictEqual(criteria.advanceThreshold, USER_STORIES_ANALYSIS_CRITERIA.advanceThreshold);
+        });
+        it('should return null for unknown phases', () => {
+            const criteria = getPhaseQualityCriteria('nonexistent_phase');
+            assert.strictEqual(criteria, null);
+        });
+        it('should apply overrides when provided', () => {
+            const criteria = getPhaseQualityCriteria('user_stories_analysis', {
+                user_stories_analysis: {
+                    advanceThreshold: 90,
+                    maxAutoRetries: 5,
+                },
+            });
+            assert.ok(criteria);
+            assert.strictEqual(criteria.advanceThreshold, 90);
+            assert.strictEqual(criteria.maxAutoRetries, 5);
+            // Non-overridden values should remain from defaults
+            assert.strictEqual(criteria.escalateThreshold, USER_STORIES_ANALYSIS_CRITERIA.escalateThreshold);
+        });
+        it('should return defaults when override map does not include the phase', () => {
+            const criteria = getPhaseQualityCriteria('technical_design', {
+                user_stories_analysis: { advanceThreshold: 90 },
+            });
+            assert.ok(criteria);
+            assert.strictEqual(criteria.advanceThreshold, TECHNICAL_DESIGN_CRITERIA.advanceThreshold);
+        });
+        it('should override criteria array when provided', () => {
+            const customCriteria = [
+                {
+                    id: 'custom_1',
+                    name: 'Custom',
+                    description: 'A custom criterion',
+                    weight: 1.0,
+                    minimumScore: 50,
+                    evaluationGuidance: 'Custom guidance',
+                },
+            ];
+            const criteria = getPhaseQualityCriteria('technical_design', {
+                technical_design: { criteria: customCriteria },
+            });
+            assert.ok(criteria);
+            assert.strictEqual(criteria.criteria.length, 1);
+            assert.strictEqual(criteria.criteria[0].id, 'custom_1');
+        });
+    });
+});

package/dist/services/lifecycle-agent/__tests__/transition-rules.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for lifecycle agent transition rules and decision logic
+ */
+export {};

package/dist/services/lifecycle-agent/__tests__/transition-rules.test.js

@@ -0,0 +1,336 @@
+/**
+ * Unit tests for lifecycle agent transition rules and decision logic
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { DEFAULT_TRANSITION_RULES, getTransitionRule, getRerunExecutionMode, getVerificationStatus, calculateQualityScore, determineDecision, buildDecisionResult, DEFAULT_LIFECYCLE_AGENT_CONFIG, } from '../transition-rules.js';
+// Helpers to create test fixtures
+function makeCriteria(overrides) {
+    return {
+        phase: 'test_phase',
+        advanceThreshold: 75,
+        escalateThreshold: 40,
+        maxAutoRetries: 2,
+        criteria: [
+            {
+                id: 'c1',
+                name: 'Criterion 1',
+                description: 'Test criterion',
+                weight: 0.6,
+                minimumScore: 50,
+                evaluationGuidance: 'Evaluate this.',
+            },
+            {
+                id: 'c2',
+                name: 'Criterion 2',
+                description: 'Another test criterion',
+                weight: 0.4,
+                minimumScore: 50,
+                evaluationGuidance: 'Evaluate this too.',
+            },
+        ],
+        ...overrides,
+    };
+}
+function makeConfig(overrides) {
+    return {
+        ...DEFAULT_LIFECYCLE_AGENT_CONFIG,
+        ...overrides,
+    };
+}
+function makeEvaluation(overrides) {
+    return {
+        phase: 'user_stories_analysis',
+        featureId: 'feat-123',
+        qualityScore: 80,
+        decision: 'advance',
+        confidence: 85,
+        criteria: [],
+        reasoning: 'Test evaluation',
+        rerunCount: 0,
+        evaluatedAt: new Date().toISOString(),
+        ...overrides,
+    };
+}
+describe('Transition Rules', () => {
+    describe('DEFAULT_TRANSITION_RULES', () => {
+        it('should cover all major phases', () => {
+            const phases = DEFAULT_TRANSITION_RULES.map((r) => r.fromPhase);
+            const expectedPhases = [
+                'user_stories_analysis',
+                'test_cases_analysis',
+                'technical_design',
+                'branch_planning',
+                'code_implementation',
+                'functional_testing',
+                'code_review',
+            ];
+            for (const phase of expectedPhases) {
+                assert.ok(phases.includes(phase), `Should have transition rule for phase: ${phase}`);
+            }
+        });
+        it('should form a connected chain from user_stories_analysis to code_refine', () => {
+            let current = 'user_stories_analysis';
+            const visited = [current];
+            while (true) {
+                const rule = DEFAULT_TRANSITION_RULES.find((r) => r.fromPhase === current);
+                if (!rule)
+                    break;
+                current = rule.toPhase;
+                visited.push(current);
+            }
+            assert.ok(visited.length > 1, 'Should form a chain of transitions');
+            assert.strictEqual(visited[0], 'user_stories_analysis', 'Chain should start at user_stories_analysis');
+            assert.strictEqual(visited[visited.length - 1], 'code_refine', 'Chain should end at code_refine');
+        });
+        it('should have valid execution modes', () => {
+            for (const rule of DEFAULT_TRANSITION_RULES) {
+                assert.ok(typeof rule.executionMode === 'string', `Rule for ${rule.fromPhase} should have a string executionMode`);
+                assert.ok(rule.executionMode.length > 0, `Rule for ${rule.fromPhase} should have non-empty executionMode`);
+            }
+        });
+    });
+    describe('getTransitionRule', () => {
+        it('should return the correct rule for known phases', () => {
+            const rule = getTransitionRule('user_stories_analysis');
+            assert.ok(rule);
+            assert.strictEqual(rule.toPhase, 'test_cases_analysis');
+            assert.strictEqual(rule.executionMode, 'only_test_cases_analysis');
+        });
+        it('should return undefined for unknown phases', () => {
+            const rule = getTransitionRule('nonexistent_phase');
+            assert.strictEqual(rule, undefined);
+        });
+        it('should return correct transition for each phase', () => {
+            const expectations = {
+                user_stories_analysis: 'test_cases_analysis',
+                test_cases_analysis: 'technical_design',
+                technical_design: 'branch_planning',
+                branch_planning: 'code_implementation',
+                code_implementation: 'functional_testing',
+                functional_testing: 'code_review',
+                code_review: 'code_refine',
+            };
+            for (const [from, expectedTo] of Object.entries(expectations)) {
+                const rule = getTransitionRule(from);
+                assert.ok(rule, `Should have rule for ${from}`);
+                assert.strictEqual(rule.toPhase, expectedTo, `${from} should transition to ${expectedTo}`);
+            }
+        });
+    });
+    describe('getRerunExecutionMode', () => {
+        it('should return only_* mode for known phases', () => {
+            assert.strictEqual(getRerunExecutionMode('user_stories_analysis'), 'only_user_stories_analysis');
+            assert.strictEqual(getRerunExecutionMode('technical_design'), 'only_technical_design');
+            assert.strictEqual(getRerunExecutionMode('code_implementation'), 'only_code_implementation');
+        });
+        it('should return full_pipeline for unknown phases', () => {
+            assert.strictEqual(getRerunExecutionMode('nonexistent'), 'full_pipeline');
+        });
+    });
+    describe('getVerificationStatus', () => {
+        it('should return verification status for phases that have one', () => {
+            assert.strictEqual(getVerificationStatus('user_stories_analysis'), 'user_stories_analysis_verification');
+            assert.strictEqual(getVerificationStatus('technical_design'), 'technical_design_verification');
+            assert.strictEqual(getVerificationStatus('code_implementation'), 'code_implementation_verification');
+        });
+        it('should return undefined for phases without verification', () => {
+            assert.strictEqual(getVerificationStatus('functional_testing'), undefined);
+            assert.strictEqual(getVerificationStatus('code_review'), undefined);
+        });
+    });
+});
+describe('Quality Score Calculation', () => {
+    describe('calculateQualityScore', () => {
+        const criteria = makeCriteria();
+        it('should calculate weighted average correctly', () => {
+            const evaluations = [
+                {
+                    criterionId: 'c1',
+                    score: 80,
+                    passed: true,
+                    reasoning: 'Good',
+                },
+                {
+                    criterionId: 'c2',
+                    score: 60,
+                    passed: true,
+                    reasoning: 'Okay',
+                },
+            ];
+            const score = calculateQualityScore(evaluations, criteria);
+            // (80 * 0.6 + 60 * 0.4) / (0.6 + 0.4) = (48 + 24) / 1 = 72
+            assert.strictEqual(score, 72);
+        });
+        it('should return 0 for empty evaluations', () => {
+            const score = calculateQualityScore([], criteria);
+            assert.strictEqual(score, 0);
+        });
+        it('should ignore evaluations for unknown criteria', () => {
+            const evaluations = [
+                {
+                    criterionId: 'c1',
+                    score: 80,
+                    passed: true,
+                    reasoning: 'Good',
+                },
+                {
+                    criterionId: 'unknown',
+                    score: 10,
+                    passed: false,
+                    reasoning: 'Unknown',
+                },
+            ];
+            const score = calculateQualityScore(evaluations, criteria);
+            // Only c1 is counted: (80 * 0.6) / 0.6 = 80
+            assert.strictEqual(score, 80);
+        });
+        it('should handle perfect scores', () => {
+            const evaluations = [
+                {
+                    criterionId: 'c1',
+                    score: 100,
+                    passed: true,
+                    reasoning: 'Perfect',
+                },
+                {
+                    criterionId: 'c2',
+                    score: 100,
+                    passed: true,
+                    reasoning: 'Perfect',
+                },
+            ];
+            const score = calculateQualityScore(evaluations, criteria);
+            assert.strictEqual(score, 100);
+        });
+        it('should handle zero scores', () => {
+            const evaluations = [
+                {
+                    criterionId: 'c1',
+                    score: 0,
+                    passed: false,
+                    reasoning: 'Failed',
+                },
+                {
+                    criterionId: 'c2',
+                    score: 0,
+                    passed: false,
+                    reasoning: 'Failed',
+                },
+            ];
+            const score = calculateQualityScore(evaluations, criteria);
+            assert.strictEqual(score, 0);
+        });
+    });
+});
+describe('Decision Logic', () => {
+    describe('determineDecision', () => {
+        const criteria = makeCriteria();
+        const config = makeConfig();
+        it('should return advance when quality meets threshold', () => {
+            const decision = determineDecision(80, 85, 0, criteria, config);
+            assert.strictEqual(decision, 'advance');
+        });
+        it('should return escalate when quality is below escalate threshold', () => {
+            const decision = determineDecision(30, 85, 0, criteria, config);
+            assert.strictEqual(decision, 'escalate');
+        });
+        it('should return rerun when quality is between thresholds', () => {
+            const decision = determineDecision(55, 85, 0, criteria, config);
+            assert.strictEqual(decision, 'rerun');
+        });
+        it('should escalate when confidence is below threshold', () => {
+            const decision = determineDecision(80, 40, 0, criteria, config);
+            assert.strictEqual(decision, 'escalate');
+        });
+        it('should escalate when max retries exhausted', () => {
+            const decision = determineDecision(55, 85, 2, criteria, config);
+            assert.strictEqual(decision, 'escalate');
+        });
+        it('should use the lower of phase and config max retries', () => {
+            const strictConfig = makeConfig({ maxAutoRetries: 1 });
+            const decision = determineDecision(55, 85, 1, criteria, strictConfig);
+            assert.strictEqual(decision, 'escalate');
+        });
+        it('should advance at exactly the advance threshold', () => {
+            const decision = determineDecision(75, 85, 0, criteria, config);
+            assert.strictEqual(decision, 'advance');
+        });
+        it('should escalate at exactly the escalate threshold', () => {
+            // At exactly 40 (escalateThreshold), the score is NOT below it,
+            // so it falls to the rerun case
+            const decision = determineDecision(40, 85, 0, criteria, config);
+            assert.strictEqual(decision, 'rerun');
+        });
+        it('should escalate just below the escalate threshold', () => {
+            const decision = determineDecision(39, 85, 0, criteria, config);
+            assert.strictEqual(decision, 'escalate');
+        });
+    });
+    describe('buildDecisionResult', () => {
+        it('should include transition rule when advancing', () => {
+            const evaluation = makeEvaluation({
+                phase: 'user_stories_analysis',
+                decision: 'advance',
+            });
+            const result = buildDecisionResult(evaluation);
+            assert.ok(result.transition);
+            assert.strictEqual(result.transition.toPhase, 'test_cases_analysis');
+            assert.strictEqual(result.executionMode, 'only_test_cases_analysis');
+            assert.strictEqual(result.targetStatus, 'test_cases_analysis');
+        });
+        it('should include rerun execution mode when rerunning', () => {
+            const evaluation = makeEvaluation({
+                phase: 'technical_design',
+                decision: 'rerun',
+            });
+            const result = buildDecisionResult(evaluation);
+            assert.strictEqual(result.transition, undefined);
+            assert.strictEqual(result.executionMode, 'only_technical_design');
+            assert.strictEqual(result.targetStatus, undefined);
+        });
+        it('should not include execution mode when escalating', () => {
+            const evaluation = makeEvaluation({
+                phase: 'code_implementation',
+                decision: 'escalate',
+            });
+            const result = buildDecisionResult(evaluation);
+            assert.strictEqual(result.transition, undefined);
+            assert.strictEqual(result.executionMode, undefined);
+            assert.strictEqual(result.targetStatus, undefined);
+        });
+        it('should preserve the evaluation in the result', () => {
+            const evaluation = makeEvaluation({
+                phase: 'test_cases_analysis',
+                qualityScore: 60,
+                decision: 'rerun',
+                reasoning: 'Needs improvement',
+            });
+            const result = buildDecisionResult(evaluation);
+            assert.strictEqual(result.evaluation, evaluation);
+            assert.strictEqual(result.evaluation.qualityScore, 60);
+            assert.strictEqual(result.evaluation.reasoning, 'Needs improvement');
+        });
+    });
+});
+describe('Default Configuration', () => {
+    describe('DEFAULT_LIFECYCLE_AGENT_CONFIG', () => {
+        it('should be disabled by default', () => {
+            assert.strictEqual(DEFAULT_LIFECYCLE_AGENT_CONFIG.enabled, false);
+        });
+        it('should disable auto-advance by default', () => {
+            assert.strictEqual(DEFAULT_LIFECYCLE_AGENT_CONFIG.autoAdvanceEnabled, false);
+        });
+        it('should enable auto-rerun by default', () => {
+            assert.strictEqual(DEFAULT_LIFECYCLE_AGENT_CONFIG.autoRerunEnabled, true);
+        });
+        it('should have a reasonable confidence threshold', () => {
+            assert.ok(DEFAULT_LIFECYCLE_AGENT_CONFIG.confidenceThreshold >= 50);
+            assert.ok(DEFAULT_LIFECYCLE_AGENT_CONFIG.confidenceThreshold <= 80);
+        });
+        it('should have a reasonable max retries', () => {
+            assert.ok(DEFAULT_LIFECYCLE_AGENT_CONFIG.maxAutoRetries >= 1);
+            assert.ok(DEFAULT_LIFECYCLE_AGENT_CONFIG.maxAutoRetries <= 5);
+        });
+    });
+});

package/dist/services/lifecycle-agent/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Lifecycle Agent Module
+ *
+ * AI-powered lifecycle management for product features.
+ * Evaluates phase outputs against quality criteria and determines
+ * whether to advance, re-run, or escalate to a human.
+ *
+ * This module provides:
+ * - Type definitions for lifecycle decisions
+ * - Quality criteria per phase
+ * - Transition rules engine
+ * - Core decision-making logic
+ *
+ * Usage:
+ *   import {
+ *     getPhaseQualityCriteria,
+ *     determineDecision,
+ *     buildDecisionResult,
+ *     DEFAULT_LIFECYCLE_AGENT_CONFIG,
+ *   } from './services/lifecycle-agent/index.js'
+ */
+export type { LifecycleDecision, CriterionEvaluation, PhaseEvaluationResult, SuggestedFeedback, CriterionDefinition, PhaseQualityCriteria, TransitionRule, LifecycleAgentConfig, LifecycleAgentState, PhaseEvaluationInput, LifecycleDecisionResult, } from './types.js';
+export { DEFAULT_PHASE_CRITERIA, USER_STORIES_ANALYSIS_CRITERIA, TEST_CASES_ANALYSIS_CRITERIA, TECHNICAL_DESIGN_CRITERIA, BRANCH_PLANNING_CRITERIA, CODE_IMPLEMENTATION_CRITERIA, FUNCTIONAL_TESTING_CRITERIA, CODE_REVIEW_CRITERIA, getPhaseQualityCriteria, } from './phase-criteria.js';
+export { DEFAULT_TRANSITION_RULES, DEFAULT_LIFECYCLE_AGENT_CONFIG, getTransitionRule, getRerunExecutionMode, getVerificationStatus, calculateQualityScore, determineDecision, buildDecisionResult, } from './transition-rules.js';

package/dist/services/lifecycle-agent/index.js

@@ -0,0 +1,25 @@
+/**
+ * Lifecycle Agent Module
+ *
+ * AI-powered lifecycle management for product features.
+ * Evaluates phase outputs against quality criteria and determines
+ * whether to advance, re-run, or escalate to a human.
+ *
+ * This module provides:
+ * - Type definitions for lifecycle decisions
+ * - Quality criteria per phase
+ * - Transition rules engine
+ * - Core decision-making logic
+ *
+ * Usage:
+ *   import {
+ *     getPhaseQualityCriteria,
+ *     determineDecision,
+ *     buildDecisionResult,
+ *     DEFAULT_LIFECYCLE_AGENT_CONFIG,
+ *   } from './services/lifecycle-agent/index.js'
+ */
+// Phase criteria
+export { DEFAULT_PHASE_CRITERIA, USER_STORIES_ANALYSIS_CRITERIA, TEST_CASES_ANALYSIS_CRITERIA, TECHNICAL_DESIGN_CRITERIA, BRANCH_PLANNING_CRITERIA, CODE_IMPLEMENTATION_CRITERIA, FUNCTIONAL_TESTING_CRITERIA, CODE_REVIEW_CRITERIA, getPhaseQualityCriteria, } from './phase-criteria.js';
+// Transition rules and decision logic
+export { DEFAULT_TRANSITION_RULES, DEFAULT_LIFECYCLE_AGENT_CONFIG, getTransitionRule, getRerunExecutionMode, getVerificationStatus, calculateQualityScore, determineDecision, buildDecisionResult, } from './transition-rules.js';

package/dist/services/lifecycle-agent/phase-criteria.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Phase Quality Criteria Definitions
+ *
+ * Defines the quality criteria the lifecycle agent uses to evaluate
+ * each phase's outputs. These criteria determine whether a phase
+ * should advance, be re-run, or be escalated to a human.
+ *
+ * Each phase has:
+ * - An advance threshold: minimum score to auto-advance
+ * - An escalate threshold: score below which to escalate to human
+ * - A set of weighted criteria for evaluation
+ * - A max retry count before escalation
+ */
+import type { PhaseQualityCriteria } from './types.js';
+/**
+ * User Stories Analysis quality criteria
+ * Evaluates whether generated user stories adequately capture the feature requirements
+ */
+export declare const USER_STORIES_ANALYSIS_CRITERIA: PhaseQualityCriteria;
+/**
+ * Test Cases Analysis quality criteria
+ * Evaluates whether generated test cases provide adequate coverage
+ */
+export declare const TEST_CASES_ANALYSIS_CRITERIA: PhaseQualityCriteria;
+/**
+ * Technical Design quality criteria
+ * Evaluates the technical design document quality
+ */
+export declare const TECHNICAL_DESIGN_CRITERIA: PhaseQualityCriteria;
+/**
+ * Branch Planning quality criteria
+ * Evaluates whether the feature is well-split into branches
+ */
+export declare const BRANCH_PLANNING_CRITERIA: PhaseQualityCriteria;
+/**
+ * Code Implementation quality criteria
+ * Evaluates the code output after implementation
+ */
+export declare const CODE_IMPLEMENTATION_CRITERIA: PhaseQualityCriteria;
+/**
+ * Functional Testing quality criteria
+ * Evaluates test execution results
+ */
+export declare const FUNCTIONAL_TESTING_CRITERIA: PhaseQualityCriteria;
+/**
+ * Code Review quality criteria
+ * Evaluates the AI code review output
+ */
+export declare const CODE_REVIEW_CRITERIA: PhaseQualityCriteria;
+/**
+ * All default phase criteria indexed by phase name
+ */
+export declare const DEFAULT_PHASE_CRITERIA: Readonly<Record<string, PhaseQualityCriteria>>;
+/**
+ * Get quality criteria for a phase, with optional overrides from config
+ */
+export declare function getPhaseQualityCriteria(phase: string, overrides?: Partial<Record<string, Partial<PhaseQualityCriteria>>>): PhaseQualityCriteria | null;