edsger 0.29.1 → 0.29.2

package/dist/commands/agent-workflow/processor.js

@@ -185,11 +185,36 @@ export class AgentWorkflowProcessor {
                 }
                 return;
             }
-            // Filter out features already being processed
-            const newFeatures = features.filter((f) => !this.activeWorkers.has(f.id));
+            // Filter out features already being processed or recently failed
+            const COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes between retries
+            const newFeatures = features.filter((f) => {
+                if (this.activeWorkers.has(f.id))
+                    return false;
+                const state = this.processedFeatures.get(f.id);
+                if (state?.status === 'failed') {
+                    // Allow retry if feature was updated after our last attempt (user intervention)
+                    if (f.updated_at && new Date(f.updated_at) > state.lastAttempt)
+                        return true;
+                    // Skip if max retries exceeded
+                    if (state.retryCount >= this.options.maxRetries)
+                        return false;
+                    // Skip if within cooldown period
+                    if (Date.now() - state.lastAttempt.getTime() < COOLDOWN_MS)
+                        return false;
+                }
+                return true;
+            });
             if (newFeatures.length === 0) {
+                // Log skipped features for debugging
+                const skippedCount = features.filter((f) => {
+                    const state = this.processedFeatures.get(f.id);
+                    return state?.status === 'failed' && state.retryCount >= this.options.maxRetries;
+                }).length;
+                if (skippedCount > 0) {
+                    logInfo(`${skippedCount} feature(s) skipped (max retries exceeded)`);
+                }
                 if (this.options.verbose) {
-                    logInfo('All available features already being processed');
+                    logInfo('No features available for processing');
                 }
                 return;
             }
@@ -329,13 +354,16 @@ export class AgentWorkflowProcessor {
         else {
             this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createFailedState(featureId, currentState));
             logError(`Feature failed: ${featureName}${error ? ` - ${error}` : ''}`);
-            // Notify chat worker about the failure
-            this.notifyChatWorker({
-                type: 'event:phase_failed',
-                featureId,
-                phase: 'workflow',
-                error: error || 'Unknown error',
-            });
+            // Only notify chat on first failure to avoid flooding with duplicate messages
+            const failedState = this.processedFeatures.get(featureId);
+            if (failedState && failedState.retryCount <= 1) {
+                this.notifyChatWorker({
+                    type: 'event:phase_failed',
+                    featureId,
+                    phase: 'workflow',
+                    error: error || 'Unknown error',
+                });
+            }
         }
         // Clear heartbeat feature info
         sendHeartbeat().catch(() => { });

package/dist/commands/workflow/feature-coordinator.js

@@ -47,7 +47,9 @@ function getPendingPhases(workflow) {
  */
 async function executePhase(phaseName, options, config) {
     const { featureId, verbose } = options;
-    const phaseRunner = PHASE_RUNNERS[phaseName];
+    // Normalize phase name: kebab-case → snake_case (e.g., code-implementation → code_implementation)
+    const normalizedName = phaseName.replace(/-/g, '_');
+    const phaseRunner = PHASE_RUNNERS[normalizedName];
     if (!phaseRunner) {
         logWarning(`Unknown workflow phase: ${phaseName}, skipping`);
         return {
@@ -58,7 +60,7 @@ async function executePhase(phaseName, options, config) {
         };
     }
     if (verbose) {
-        logInfo(`\n🎯 Executing phase: ${phaseName}`);
+        logInfo(`\n🎯 Executing phase: ${normalizedName}`);
     }
     // Execute the phase
     const result = await phaseRunner(options, config);
@@ -66,7 +68,7 @@ async function executePhase(phaseName, options, config) {
     logPhaseResult(result, verbose);
     // Mark workflow phase as completed if successful
     if (result.status === 'success') {
-        await markWorkflowPhaseCompleted(featureId, phaseName, verbose);
+        await markWorkflowPhaseCompleted(featureId, normalizedName, verbose);
     }
     return result;
 }

package/dist/phases/chat-processor/tools.js

@@ -32,7 +32,32 @@ export function createChatMcpServer() {
             }),
             tool('update_execution_mode', 'Change the feature execution mode (e.g., from_user_stories_analysis, from_code_implementation).', {
                 feature_id: z.string().describe('Feature ID'),
-                execution_mode: z.string().describe('New execution mode'),
+                execution_mode: z.enum([
+                    'full_pipeline',
+                    'only_feature_analysis',
+                    'only_user_stories_analysis',
+                    'only_test_cases_analysis',
+                    'only_technical_design',
+                    'only_branch_planning',
+                    'only_code_implementation',
+                    'only_pr_splitting',
+                    'only_pr_execution',
+                    'only_functional_testing',
+                    'only_code_refine',
+                    'only_code_review',
+                    'from_feature_analysis',
+                    'from_user_stories_analysis',
+                    'from_test_cases_analysis',
+                    'from_technical_design',
+                    'from_branch_planning',
+                    'from_code_implementation',
+                    'from_pr_splitting',
+                    'from_pr_execution',
+                    'from_functional_testing',
+                    'from_code_review',
+                    'custom',
+                    'autonomous',
+                ]).describe('New execution mode'),
             }, async (args) => {
                 const result = await callMcpEndpoint('features/update', {
                     feature_id: args.feature_id,
@@ -42,18 +67,23 @@ export function createChatMcpServer() {
                     content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                 };
             }),
-            tool('update_workflow', 'Modify workflow phases — reset phases to pending, skip phases, or reorder.', {
+            tool('update_workflow', 'Modify workflow phases — reset phases to pending, skip phases, or reorder. Phase names must use snake_case (e.g., code_implementation, NOT code-implementation).', {
                 feature_id: z.string().describe('Feature ID'),
                 workflow: z
                     .array(z.object({
-                    phase: z.string(),
+                    phase: z.string().describe('Phase name in snake_case. Valid phases: feature_analysis, user_stories_analysis, test_cases_analysis, technical_design, branch_planning, code_implementation, pr_splitting, pr_execution, functional_testing, code_review, code_refine, autonomous'),
                     status: z.enum(['pending', 'completed', 'skipped']),
                 }))
                     .describe('Updated workflow array'),
             }, async (args) => {
+                // Normalize phase names: kebab-case → snake_case
+                const normalizedWorkflow = args.workflow.map((p) => ({
+                    ...p,
+                    phase: p.phase.replace(/-/g, '_'),
+                }));
                 const result = await callMcpEndpoint('features/update', {
                     feature_id: args.feature_id,
-                    workflow: args.workflow,
+                    workflow: normalizedWorkflow,
                 });
                 return {
                     content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
@@ -72,7 +102,7 @@ export function createChatMcpServer() {
                         .describe('Required for update/delete'),
                     title: z.string().optional(),
                     description: z.string().optional(),
-                    status: z.enum(['draft', 'ready', 'approved']).optional(),
+                    status: z.enum(['draft', 'pending_approval', 'approved']).optional(),
                 })),
             }, async (args) => {
                 const results = [];

package/dist/phases/feature-analysis/index.js

@@ -11,7 +11,7 @@ export const analyseFeature = async (options, config, checklistContext) => {
         logInfo(`Starting feature analysis for feature ID: ${featureId}`);
     }
     try {
-        // Reset ready artifacts to draft so AI can manage them on re-run
+        // Reset pending_approval artifacts to draft so AI can manage them on re-run
         const resetResult = await resetReadyArtifactsToDraft(featureId, verbose);
         if (verbose && (resetResult.resetUserStories > 0 || resetResult.resetTestCases > 0)) {
             logInfo(`✅ Reset ${resetResult.resetUserStories} user stories and ${resetResult.resetTestCases} test cases to draft for re-analysis`);
@@ -86,10 +86,10 @@ export const analyseFeature = async (options, config, checklistContext) => {
             // Perform verification cycle
             const verificationCycle = await performVerificationCycle(structuredAnalysisResult, checklistContext || null, context.featureContext, config, currentIteration, maxIterations, featureId, verbose);
             verificationResult = verificationCycle.verificationResult;
-            // If verification passed, update ALL remaining draft artifacts to ready and exit
+            // If verification passed, update ALL remaining draft artifacts to pending_approval and exit
             if (verificationCycle.passed) {
                 if (verbose) {
-                    logInfo('✅ Verification passed! Updating all draft artifacts to ready status...');
+                    logInfo('✅ Verification passed! Updating all draft artifacts to pending_approval status...');
                 }
                 const allDrafts = await getAllDraftArtifactIds(featureId, verbose);
                 await updateArtifactsToReady(allDrafts.userStoryIds, allDrafts.testCaseIds, verbose);
@@ -118,7 +118,7 @@ export const analyseFeature = async (options, config, checklistContext) => {
         if (!structuredAnalysisResult) {
             throw new Error('No analysis results received');
         }
-        // If no checklist was used, update all draft artifacts to ready now
+        // If no checklist was used, update all draft artifacts to pending_approval now
         if (!checklistContext ||
             checklistContext.checklists.length === 0 ||
             !verificationResult) {
@@ -126,7 +126,7 @@ export const analyseFeature = async (options, config, checklistContext) => {
             if (allDrafts.userStoryIds.length > 0 ||
                 allDrafts.testCaseIds.length > 0) {
                 if (verbose) {
-                    logInfo('✅ No checklist verification needed. Updating all draft artifacts to ready status...');
+                    logInfo('✅ No checklist verification needed. Updating all draft artifacts to pending_approval status...');
                 }
                 await updateArtifactsToReady(allDrafts.userStoryIds, allDrafts.testCaseIds, verbose);
             }
@@ -143,7 +143,7 @@ export const analyseFeature = async (options, config, checklistContext) => {
             throw new Error(`Checklist verification failed after ${currentIteration} iterations`);
         }
         // Return success result
-        // Note: Artifacts have already been saved and updated to 'ready' status (if verification passed)
+        // Note: Artifacts have already been saved and updated to 'pending_approval' status (if verification passed)
         // or remain as draft (if verification failed)
         return buildAnalysisResult(featureId, context.featureContext, structuredAnalysisResult, currentIteration);
     }

package/dist/phases/feature-analysis/outcome.d.ts

@@ -24,7 +24,7 @@ export declare function deleteArtifacts(userStoryIds: string[], testCaseIds: str
  */
 export declare function deleteSpecificArtifacts(featureId: string, deletedUserStoryIds: string[], deletedTestCaseIds: string[], deletionReasons: Record<string, string>, verbose?: boolean): Promise<void>;
 /**
- * Update artifacts to ready status after successful verification
+ * Update artifacts to pending_approval status after successful verification
  */
 export declare function updateArtifactsToReady(userStoryIds: string[], testCaseIds: string[], verbose?: boolean): Promise<void>;
 /**

package/dist/phases/feature-analysis/outcome.js

@@ -10,10 +10,10 @@ export async function resetReadyArtifactsToDraft(featureId, verbose) {
         getTestCases(featureId, false),
     ]);
     const readyStoryIds = stories
-        .filter((s) => s.status === 'ready')
+        .filter((s) => s.status === 'pending_approval')
         .map((s) => s.id);
     const readyTestCaseIds = testCases
-        .filter((tc) => tc.status === 'ready')
+        .filter((tc) => tc.status === 'pending_approval')
         .map((tc) => tc.id);
     if (readyStoryIds.length > 0) {
         if (verbose) {
@@ -144,20 +144,20 @@ export async function deleteSpecificArtifacts(featureId, deletedUserStoryIds, de
     }
 }
 /**
- * Update artifacts to ready status after successful verification
+ * Update artifacts to pending_approval status after successful verification
  */
 export async function updateArtifactsToReady(userStoryIds, testCaseIds, verbose) {
     if (userStoryIds.length > 0) {
         if (verbose) {
-            logInfo(`Updating ${userStoryIds.length} user stories from draft to ready...`);
+            logInfo(`Updating ${userStoryIds.length} user stories from draft to pending_approval...`);
         }
-        await batchUpdateUserStoryStatus(userStoryIds, 'ready', verbose);
+        await batchUpdateUserStoryStatus(userStoryIds, 'pending_approval', verbose);
     }
     if (testCaseIds.length > 0) {
         if (verbose) {
-            logInfo(`Updating ${testCaseIds.length} test cases from draft to ready...`);
+            logInfo(`Updating ${testCaseIds.length} test cases from draft to pending_approval...`);
         }
-        await batchUpdateTestCaseStatus(testCaseIds, 'ready', verbose);
+        await batchUpdateTestCaseStatus(testCaseIds, 'pending_approval', verbose);
     }
 }
 /**
@@ -230,7 +230,7 @@ export function buildAnalysisResult(featureId, context, structuredAnalysisResult
         featureInfo: context.feature,
         existingUserStories: context.existing_user_stories.map((story) => ({
             ...story,
-            status: (story.status === 'ready' ? 'ready' : story.status === 'approved' ? 'approved' : 'draft'),
+            status: (story.status === 'pending_approval' ? 'pending_approval' : story.status === 'approved' ? 'approved' : 'draft'),
             created_at: story.created_at || new Date().toISOString(),
             updated_at: story.updated_at || new Date().toISOString(),
         })),

package/dist/phases/test-cases-analysis/index.js

@@ -11,10 +11,10 @@ export const analyseTestCases = async (options, config, checklistContext) => {
         logInfo(`Starting test cases analysis for feature ID: ${featureId}`);
     }
     try {
-        // Reset ready test cases to draft so AI can manage them on re-run
+        // Reset pending_approval test cases to draft so AI can manage them on re-run
         const resetCount = await resetReadyTestCasesToDraft(featureId, verbose);
         if (verbose && resetCount > 0) {
-            logInfo(`✅ Reset ${resetCount} ready test cases to draft for re-analysis`);
+            logInfo(`✅ Reset ${resetCount} pending_approval test cases to draft for re-analysis`);
         }
         const context = await prepareTestCasesAnalysisContext(featureId, checklistContext, verbose);
         const systemPrompt = createTestCasesAnalysisSystemPrompt();
@@ -83,7 +83,7 @@ export const analyseTestCases = async (options, config, checklistContext) => {
             verificationResult = verificationCycle.verificationResult;
             if (verificationCycle.passed) {
                 if (verbose) {
-                    logInfo('✅ Verification passed! Updating all draft test cases to ready status...');
+                    logInfo('✅ Verification passed! Updating all draft test cases to pending_approval status...');
                 }
                 // Update ALL remaining draft test cases (both kept old ones and newly created)
                 const allDraftIds = await getAllDraftTestCaseIds(featureId, verbose);
@@ -107,14 +107,14 @@ export const analyseTestCases = async (options, config, checklistContext) => {
         if (!structuredAnalysisResult) {
             throw new Error('No analysis results received');
         }
-        // If no checklist was used, update all draft artifacts to ready
+        // If no checklist was used, update all draft artifacts to pending_approval
         if (!checklistContext ||
             checklistContext.checklists.length === 0 ||
             !verificationResult) {
             const allDraftIds = await getAllDraftTestCaseIds(featureId, verbose);
             if (allDraftIds.length > 0) {
                 if (verbose) {
-                    logInfo('✅ No checklist verification needed. Updating all draft test cases to ready status...');
+                    logInfo('✅ No checklist verification needed. Updating all draft test cases to pending_approval status...');
                 }
                 await updateTestCasesToReady(allDraftIds, verbose);
             }

package/dist/phases/test-cases-analysis/outcome.js

@@ -4,7 +4,7 @@ import { callMcpEndpoint } from '../../api/mcp-client.js';
 export async function resetReadyTestCasesToDraft(featureId, verbose) {
     const testCases = await getTestCases(featureId, false);
     const readyIds = testCases
-        .filter((tc) => tc.status === 'ready')
+        .filter((tc) => tc.status === 'pending_approval')
         .map((tc) => tc.id);
     if (readyIds.length === 0) {
         return 0;
@@ -70,9 +70,9 @@ export async function deleteSpecificTestCases(featureId, deletedTestCaseIds, del
 export async function updateTestCasesToReady(testCaseIds, verbose) {
     if (testCaseIds.length > 0) {
         if (verbose) {
-            logInfo(`Updating ${testCaseIds.length} test cases from draft to ready...`);
+            logInfo(`Updating ${testCaseIds.length} test cases from draft to pending_approval...`);
         }
-        await batchUpdateTestCaseStatus(testCaseIds, 'ready', verbose);
+        await batchUpdateTestCaseStatus(testCaseIds, 'pending_approval', verbose);
     }
 }
 export async function saveTestCasesAsDraft(featureId, created_test_cases, verbose) {

package/dist/phases/user-stories-analysis/index.js

@@ -11,10 +11,10 @@ export const analyseUserStories = async (options, config, checklistContext) => {
         logInfo(`Starting user stories analysis for feature ID: ${featureId}`);
     }
     try {
-        // Reset ready user stories to draft so AI can manage them on re-run
+        // Reset pending_approval user stories to draft so AI can manage them on re-run
         const resetCount = await resetReadyUserStoriesToDraft(featureId, verbose);
         if (verbose && resetCount > 0) {
-            logInfo(`✅ Reset ${resetCount} ready user stories to draft for re-analysis`);
+            logInfo(`✅ Reset ${resetCount} pending_approval user stories to draft for re-analysis`);
         }
         const context = await prepareUserStoriesAnalysisContext(featureId, checklistContext, verbose);
         const systemPrompt = createUserStoriesAnalysisSystemPrompt();
@@ -83,7 +83,7 @@ export const analyseUserStories = async (options, config, checklistContext) => {
             verificationResult = verificationCycle.verificationResult;
             if (verificationCycle.passed) {
                 if (verbose) {
-                    logInfo('✅ Verification passed! Updating all draft user stories to ready status...');
+                    logInfo('✅ Verification passed! Updating all draft user stories to pending_approval status...');
                 }
                 // Update ALL remaining draft stories (both kept old ones and newly created)
                 const allDraftIds = await getAllDraftUserStoryIds(featureId, verbose);
@@ -107,14 +107,14 @@ export const analyseUserStories = async (options, config, checklistContext) => {
         if (!structuredAnalysisResult) {
             throw new Error('No analysis results received');
         }
-        // If no checklist was used, update all draft artifacts to ready
+        // If no checklist was used, update all draft artifacts to pending_approval
         if (!checklistContext ||
             checklistContext.checklists.length === 0 ||
             !verificationResult) {
             const allDraftIds = await getAllDraftUserStoryIds(featureId, verbose);
             if (allDraftIds.length > 0) {
                 if (verbose) {
-                    logInfo('✅ No checklist verification needed. Updating all draft user stories to ready status...');
+                    logInfo('✅ No checklist verification needed. Updating all draft user stories to pending_approval status...');
                 }
                 await updateUserStoriesToReady(allDraftIds, verbose);
             }

package/dist/phases/user-stories-analysis/outcome.js

@@ -4,7 +4,7 @@ import { callMcpEndpoint } from '../../api/mcp-client.js';
 export async function resetReadyUserStoriesToDraft(featureId, verbose) {
     const stories = await getUserStories(featureId, false);
     const readyStoryIds = stories
-        .filter((story) => story.status === 'ready')
+        .filter((story) => story.status === 'pending_approval')
         .map((story) => story.id);
     if (readyStoryIds.length === 0) {
         return 0;
@@ -70,9 +70,9 @@ export async function deleteSpecificUserStories(featureId, deletedUserStoryIds,
 export async function updateUserStoriesToReady(userStoryIds, verbose) {
     if (userStoryIds.length > 0) {
         if (verbose) {
-            logInfo(`Updating ${userStoryIds.length} user stories from draft to ready...`);
+            logInfo(`Updating ${userStoryIds.length} user stories from draft to pending_approval...`);
         }
-        await batchUpdateUserStoryStatus(userStoryIds, 'ready', verbose);
+        await batchUpdateUserStoryStatus(userStoryIds, 'pending_approval', verbose);
     }
 }
 export async function saveUserStoriesAsDraft(featureId, created_user_stories, verbose) {
@@ -111,7 +111,7 @@ export function buildUserStoriesAnalysisResult(featureId, context, structuredAna
         featureInfo: context.feature,
         existingUserStories: context.existing_user_stories.map((story) => ({
             ...story,
-            status: (story.status === 'ready' ? 'ready' : 'draft'),
+            status: (story.status === 'pending_approval' ? 'pending_approval' : 'draft'),
             created_at: story.created_at || new Date().toISOString(),
             updated_at: story.updated_at || new Date().toISOString(),
         })),

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 {};