edsger 0.45.1 → 0.47.0

package/dist/phases/smoke-test/snapshot.js

@@ -0,0 +1,157 @@
+/**
+ * Snapshot detection: after the latest GitHub release already has a
+ * smoke-test plan, inspect the cloned repo for a yet-to-be-released
+ * "snapshot" version (next package.json version, an [Unreleased] entry
+ * in CHANGELOG, an unreleased git tag, etc.) so we can prepare the
+ * next smoke test before anyone cuts the tag on GitHub.
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { logDebug, logInfo } from '../../utils/logger.js';
+import { findBalancedJsonObject } from './agent.js';
+export function buildSnapshotDetectionPrompt(latestReleaseTag) {
+    return `You are inspecting a code repository to decide whether an unreleased "snapshot" version is being prepared.
+
+The most recent shipped release on GitHub is tagged: **${latestReleaseTag}**
+
+Your job:
+
+1. Read the repository's primary version source. In priority order:
+   - package.json "version" field (JS/TS projects)
+   - Cargo.toml [package] version (Rust)
+   - pyproject.toml [project] / [tool.poetry] version (Python)
+   - pom.xml <version> (Java / Maven)
+   - VERSION file (plain text)
+2. Read CHANGELOG.md / HISTORY.md / RELEASES.md for an [Unreleased] or similarly labelled section.
+3. Run \`git tag --list\` and \`git tag --sort=-creatordate | head -5\` to look for tags newer than ${latestReleaseTag} that have not yet been cut as GitHub releases.
+
+Then decide:
+- If the primary version source is strictly greater than ${latestReleaseTag} (accounting for "v" prefixes and semver prerelease suffixes like \`-SNAPSHOT\`, \`-rc.1\`, \`-next.0\`), OR there is a newer unreleased git tag, report that string as \`snapshot_tag\`.
+- Otherwise report \`snapshot_tag: null\`.
+- Do NOT invent a version. Use the exact string from the source file. Preserve the repo's existing tag convention (e.g. if releases are \`v1.2.3\` but package.json says \`1.2.3\`, return \`v1.2.3\`).
+
+Respond with ONLY a JSON object — no prose, no markdown fences:
+
+{
+  "snapshot_tag": "v2.0.0" | null,
+  "source": "package.json" | "Cargo.toml" | "pyproject.toml" | "pom.xml" | "VERSION" | "CHANGELOG" | "git_tag" | null,
+  "reasoning": "<one sentence>"
+}`;
+}
+export function parseSnapshotDetection(raw) {
+    let body = raw.trim();
+    const fence = body.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fence) {
+        body = fence[1].trim();
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        const object = findBalancedJsonObject(body);
+        if (!object) {
+            throw new Error('No JSON object found in snapshot-detection output');
+        }
+        parsed = JSON.parse(object);
+    }
+    if (typeof parsed !== 'object' || parsed === null) {
+        throw new Error('Snapshot detection returned non-object response');
+    }
+    const obj = parsed;
+    const rawTag = obj.snapshot_tag;
+    const snapshotTag = typeof rawTag === 'string' && rawTag.trim().length > 0
+        ? rawTag.trim()
+        : null;
+    const source = typeof obj.source === 'string' ? obj.source : null;
+    const reasoning = typeof obj.reasoning === 'string' ? obj.reasoning : '(no reasoning given)';
+    return { snapshot_tag: snapshotTag, source, reasoning };
+}
+/**
+ * Very loose sanity check on a proposed snapshot tag. We reject tags
+ * that are obviously the same as the latest release or that contain
+ * characters that would break downstream git / GitHub API calls.
+ */
+export function isPlausibleSnapshotTag(candidate, latestReleaseTag) {
+    if (candidate === latestReleaseTag) {
+        return false;
+    }
+    if (candidate.length === 0 || candidate.length > 100) {
+        return false;
+    }
+    if (/\s/.test(candidate)) {
+        return false;
+    }
+    if (/^[-.]/.test(candidate) || candidate.includes('..') || candidate.includes('@{')) {
+        return false;
+    }
+    return /^[A-Za-z0-9._\-+/@]+$/.test(candidate);
+}
+function userMessage(content) {
+    return { type: 'user', message: { role: 'user', content } };
+}
+// eslint-disable-next-line @typescript-eslint/require-await -- async generator required by SDK interface
+async function* makePrompt(text) {
+    yield userMessage(text);
+}
+// eslint-disable-next-line complexity -- agent loop with message-type handling
+export async function detectSnapshotVersion(options) {
+    const { cwd, latestReleaseTag, config, verbose } = options;
+    if (verbose) {
+        logInfo(`Detecting snapshot version ahead of ${latestReleaseTag}...`);
+    }
+    let lastAssistant = '';
+    let detection = null;
+    for await (const message of query({
+        prompt: makePrompt(buildSnapshotDetectionPrompt(latestReleaseTag)),
+        options: {
+            systemPrompt: {
+                type: 'preset',
+                preset: 'claude_code',
+            },
+            model: config.model || DEFAULT_MODEL,
+            maxTurns: 10,
+            permissionMode: 'bypassPermissions',
+            cwd,
+        },
+    })) {
+        if (message.type === 'assistant' && message.message?.content) {
+            for (const content of message.message.content) {
+                if (content.type === 'text') {
+                    lastAssistant += `${content.text}\n`;
+                    logDebug(content.text, verbose);
+                }
+            }
+        }
+        if (message.type === 'result') {
+            const text = message.result || lastAssistant;
+            try {
+                detection = parseSnapshotDetection(text);
+            }
+            catch (err) {
+                if (verbose) {
+                    logDebug(`Snapshot detection parse error: ${err instanceof Error ? err.message : String(err)}`, verbose);
+                }
+            }
+        }
+    }
+    if (!detection) {
+        return {
+            snapshot_tag: null,
+            source: null,
+            reasoning: 'Could not parse detection response',
+        };
+    }
+    // Validate the proposed tag before returning.
+    if (detection.snapshot_tag !== null &&
+        !isPlausibleSnapshotTag(detection.snapshot_tag, latestReleaseTag)) {
+        if (verbose) {
+            logInfo(`Rejecting implausible snapshot tag: ${JSON.stringify(detection.snapshot_tag)}`);
+        }
+        return {
+            ...detection,
+            snapshot_tag: null,
+        };
+    }
+    return detection;
+}

package/dist/phases/technical-design/index.js

@@ -24,9 +24,8 @@ async function* prompt(analysisPrompt) {
         setTimeout(res, 10000);
     });
 }
-export const generateTechnicalDesign = async (options, config, checklistContext
 // eslint-disable-next-line complexity
-) => {
+export const generateTechnicalDesign = async (options, config, checklistContext) => {
     const { featureId, verbose } = options;
     if (verbose) {
         logInfo(`Starting technical design generation for feature ID: ${featureId}`);

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

@@ -6,9 +6,8 @@ import { executeTestCasesAnalysisQuery, parseAnalysisResult } from './agent.js';
 import { prepareTestCasesAnalysisContext } from './context.js';
 import { buildTestCasesAnalysisResult, deleteSpecificTestCases, deleteTestCaseArtifacts, getAllDraftTestCaseIds, resetReadyTestCasesToDraft, saveTestCasesAsDraft, updateTestCasesToReady, } from './outcome.js';
 import { createTestCasesAnalysisSystemPrompt } from './prompts.js';
-export const analyseTestCases = async (options, config, checklistContext
 // eslint-disable-next-line complexity
-) => {
+export const analyseTestCases = async (options, config, checklistContext) => {
     const { featureId, verbose } = options;
     if (verbose) {
         logInfo(`Starting test cases analysis for feature ID: ${featureId}`);

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

@@ -6,9 +6,8 @@ import { executeUserStoriesAnalysisQuery, parseAnalysisResult, } from './agent.j
 import { prepareUserStoriesAnalysisContext } from './context.js';
 import { buildUserStoriesAnalysisResult, deleteSpecificUserStories, deleteUserStoryArtifacts, getAllDraftUserStoryIds, resetReadyUserStoriesToDraft, saveUserStoriesAsDraft, updateUserStoriesToReady, } from './outcome.js';
 import { createUserStoriesAnalysisSystemPrompt } from './prompts.js';
-export const analyseUserStories = async (options, config, checklistContext
 // eslint-disable-next-line complexity
-) => {
+export const analyseUserStories = async (options, config, checklistContext) => {
     const { featureId, verbose } = options;
     if (verbose) {
         logInfo(`Starting user stories analysis for feature ID: ${featureId}`);

package/dist/services/coaching/__tests__/coaching-agent.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/coaching/__tests__/coaching-agent.test.js

@@ -0,0 +1,74 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { buildImprovementPrompt, } from '../coaching-agent.js';
+void describe('buildImprovementPrompt', () => {
+    const decision = {
+        shouldContinue: true,
+        reasoning: 'Completeness is weak, needs more coverage',
+        focusAreas: ['completeness', 'accuracy'],
+        suggestions: [
+            'Add error handling section',
+            'Include database migration plan',
+        ],
+    };
+    const rating = {
+        score: 72,
+        summary: 'Decent but incomplete',
+        criteria_scores: {
+            completeness: { score: 60, reason: 'Missing sections' },
+            accuracy: { score: 75, reason: 'Minor issues' },
+            quality: { score: 82, reason: 'Good structure' },
+        },
+        strengths: ['Clean structure'],
+        weaknesses: ['Missing error handling', 'No migration plan'],
+    };
+    void it('includes current score and target', () => {
+        const prompt = buildImprovementPrompt(decision, rating);
+        assert.ok(prompt.includes('72/100'));
+        assert.ok(prompt.includes('100/100'));
+    });
+    void it('includes coaching reasoning', () => {
+        const prompt = buildImprovementPrompt(decision, rating);
+        assert.ok(prompt.includes('Completeness is weak, needs more coverage'));
+    });
+    void it('includes focus areas with scores', () => {
+        const prompt = buildImprovementPrompt(decision, rating);
+        assert.ok(prompt.includes('completeness'));
+        assert.ok(prompt.includes('60/100'));
+        assert.ok(prompt.includes('accuracy'));
+        assert.ok(prompt.includes('75/100'));
+    });
+    void it('includes specific suggestions', () => {
+        const prompt = buildImprovementPrompt(decision, rating);
+        assert.ok(prompt.includes('Add error handling section'));
+        assert.ok(prompt.includes('Include database migration plan'));
+    });
+    void it('includes weaknesses to address', () => {
+        const prompt = buildImprovementPrompt(decision, rating);
+        assert.ok(prompt.includes('Missing error handling'));
+        assert.ok(prompt.includes('No migration plan'));
+    });
+    void it('handles empty focus areas gracefully', () => {
+        const emptyDecision = {
+            shouldContinue: true,
+            reasoning: 'General improvement needed',
+            focusAreas: [],
+            suggestions: ['Improve overall'],
+        };
+        const prompt = buildImprovementPrompt(emptyDecision, rating);
+        assert.ok(prompt.includes('General improvement needed'));
+        assert.ok(prompt.includes('Improve overall'));
+    });
+    void it('handles focus areas not present in criteria_scores', () => {
+        const decisionWithUnknown = {
+            shouldContinue: true,
+            reasoning: 'test',
+            focusAreas: ['nonexistent_criterion'],
+            suggestions: ['test'],
+        };
+        const prompt = buildImprovementPrompt(decisionWithUnknown, rating);
+        // Should not crash, should show '?' for missing score
+        assert.ok(prompt.includes('nonexistent_criterion'));
+        assert.ok(prompt.includes('?/100'));
+    });
+});

package/dist/services/coaching/__tests__/coaching-loop.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/coaching/__tests__/coaching-loop.test.js

@@ -0,0 +1,59 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { isStagnant } from '../coaching-loop.js';
+function makeRating(score) {
+    return {
+        score,
+        summary: `Score: ${score}`,
+        criteria_scores: {},
+        strengths: [],
+        weaknesses: [],
+    };
+}
+void describe('isStagnant', () => {
+    void it('returns false when fewer than 3 ratings', () => {
+        assert.strictEqual(isStagnant([]), false);
+        assert.strictEqual(isStagnant([makeRating(50)]), false);
+        assert.strictEqual(isStagnant([makeRating(50), makeRating(52)]), false);
+    });
+    void it('returns true when 3 ratings with < 3 point improvement', () => {
+        const ratings = [makeRating(80), makeRating(81), makeRating(82)];
+        assert.strictEqual(isStagnant(ratings), true);
+    });
+    void it('returns true when 3 ratings with zero improvement', () => {
+        const ratings = [makeRating(85), makeRating(85), makeRating(85)];
+        assert.strictEqual(isStagnant(ratings), true);
+    });
+    void it('returns false when improvement >= 3 points', () => {
+        // 73 - 70 = 3, and MIN_IMPROVEMENT = 3, so 3 < 3 is false → not stagnant
+        const ratings = [makeRating(70), makeRating(72), makeRating(73)];
+        assert.strictEqual(isStagnant(ratings), false);
+    });
+    void it('returns false when improvement exactly equals threshold', () => {
+        const ratings = [makeRating(70), makeRating(72), makeRating(73)];
+        // improvement = 73 - 70 = 3, MIN_IMPROVEMENT = 3
+        // 3 < 3 is false → not stagnant
+        assert.strictEqual(isStagnant(ratings), false);
+    });
+    void it('returns false when improvement exceeds threshold', () => {
+        const ratings = [makeRating(60), makeRating(65), makeRating(70)];
+        assert.strictEqual(isStagnant(ratings), false);
+    });
+    void it('only looks at last STAGNATION_WINDOW ratings', () => {
+        // Early ratings had big jumps, but last 3 are flat
+        const ratings = [
+            makeRating(30),
+            makeRating(50),
+            makeRating(70),
+            makeRating(71),
+            makeRating(72),
+        ];
+        // Last 3: 70, 71, 72 → improvement = 2 < 3 → stagnant
+        assert.strictEqual(isStagnant(ratings), true);
+    });
+    void it('handles decreasing scores as stagnant', () => {
+        const ratings = [makeRating(80), makeRating(78), makeRating(79)];
+        // improvement = 79 - 80 = -1 < 3 → stagnant
+        assert.strictEqual(isStagnant(ratings), true);
+    });
+});

package/dist/services/coaching/__tests__/self-rating.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/coaching/__tests__/self-rating.test.js

@@ -0,0 +1,188 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { buildSelfRatingPrompt, getCriteriaForPhase, parseSelfRating, } from '../self-rating.js';
+void describe('getCriteriaForPhase', () => {
+    void it('returns analysis criteria for feature_analysis', () => {
+        const criteria = getCriteriaForPhase('feature_analysis');
+        assert.ok(criteria.includes('coverage'));
+        assert.ok(criteria.includes('clarity'));
+        assert.ok(criteria.includes('completeness'));
+    });
+    void it('returns analysis criteria for user_stories_analysis', () => {
+        const criteria = getCriteriaForPhase('user_stories_analysis');
+        assert.ok(criteria.includes('coverage'));
+    });
+    void it('returns analysis criteria for test_cases_analysis', () => {
+        const criteria = getCriteriaForPhase('test_cases_analysis');
+        assert.ok(criteria.includes('clarity'));
+    });
+    void it('returns design criteria for technical_design', () => {
+        const criteria = getCriteriaForPhase('technical_design');
+        assert.ok(criteria.includes('feasibility'));
+        assert.ok(criteria.includes('scalability'));
+        assert.ok(criteria.includes('maintainability'));
+    });
+    void it('returns design criteria for branch_planning', () => {
+        const criteria = getCriteriaForPhase('branch_planning');
+        assert.ok(criteria.includes('feasibility'));
+    });
+    void it('returns code criteria for code_implementation', () => {
+        const criteria = getCriteriaForPhase('code_implementation');
+        assert.ok(criteria.includes('readability'));
+        assert.ok(criteria.includes('testability'));
+        assert.ok(criteria.includes('performance'));
+        assert.ok(criteria.includes('security'));
+    });
+    void it('returns code criteria for code_refine', () => {
+        const criteria = getCriteriaForPhase('code_refine');
+        assert.ok(criteria.includes('readability'));
+    });
+    void it('returns common criteria for autonomous', () => {
+        const criteria = getCriteriaForPhase('autonomous');
+        assert.ok(criteria.includes('completeness'));
+        assert.ok(criteria.includes('accuracy'));
+        assert.ok(criteria.includes('quality'));
+        assert.ok(criteria.includes('consistency'));
+    });
+    void it('all criteria sets include common criteria', () => {
+        const phases = [
+            'feature_analysis',
+            'technical_design',
+            'code_implementation',
+            'autonomous',
+        ];
+        for (const phase of phases) {
+            const criteria = getCriteriaForPhase(phase);
+            assert.ok(criteria.includes('completeness'), `${phase} missing completeness`);
+            assert.ok(criteria.includes('accuracy'), `${phase} missing accuracy`);
+            assert.ok(criteria.includes('quality'), `${phase} missing quality`);
+            assert.ok(criteria.includes('consistency'), `${phase} missing consistency`);
+        }
+    });
+});
+void describe('buildSelfRatingPrompt', () => {
+    void it('includes phase-specific criteria', () => {
+        const prompt = buildSelfRatingPrompt('technical_design');
+        assert.ok(prompt.includes('"feasibility"'));
+        assert.ok(prompt.includes('"scalability"'));
+        assert.ok(prompt.includes('"maintainability"'));
+    });
+    void it('includes JSON structure template', () => {
+        const prompt = buildSelfRatingPrompt('code_implementation');
+        assert.ok(prompt.includes('"self_rating"'));
+        assert.ok(prompt.includes('"score"'));
+        assert.ok(prompt.includes('"criteria_scores"'));
+        assert.ok(prompt.includes('"strengths"'));
+        assert.ok(prompt.includes('"weaknesses"'));
+    });
+    void it('asks for 0-100 scores', () => {
+        const prompt = buildSelfRatingPrompt('feature_analysis');
+        assert.ok(prompt.includes('0-100'));
+    });
+});
+void describe('parseSelfRating', () => {
+    void it('parses valid JSON in markdown code block', () => {
+        const response = `Here is my self-rating:
+
+\`\`\`json
+{
+  "self_rating": {
+    "score": 85,
+    "summary": "Good coverage but some gaps",
+    "criteria_scores": {
+      "completeness": { "score": 90, "reason": "Covered all cases" },
+      "accuracy": { "score": 80, "reason": "Minor issues" }
+    },
+    "strengths": ["Good structure", "Clear naming"],
+    "weaknesses": ["Missing edge cases"]
+  }
+}
+\`\`\``;
+        const rating = parseSelfRating(response, 'technical_design');
+        assert.ok(rating);
+        assert.strictEqual(rating.score, 85);
+        assert.strictEqual(rating.summary, 'Good coverage but some gaps');
+        assert.strictEqual(rating.criteria_scores.completeness.score, 90);
+        assert.strictEqual(rating.criteria_scores.accuracy.score, 80);
+        assert.deepStrictEqual(rating.strengths, ['Good structure', 'Clear naming']);
+        assert.deepStrictEqual(rating.weaknesses, ['Missing edge cases']);
+    });
+    void it('parses raw JSON without code block', () => {
+        const response = JSON.stringify({
+            self_rating: {
+                score: 72,
+                summary: 'Needs work',
+                criteria_scores: {},
+                strengths: [],
+                weaknesses: ['Poor coverage'],
+            },
+        });
+        const rating = parseSelfRating(response, 'feature_analysis');
+        assert.ok(rating);
+        assert.strictEqual(rating.score, 72);
+        assert.strictEqual(rating.summary, 'Needs work');
+    });
+    void it('rounds score to integer', () => {
+        const response = JSON.stringify({
+            self_rating: {
+                score: 85.7,
+                summary: 'test',
+                criteria_scores: {},
+                strengths: [],
+                weaknesses: [],
+            },
+        });
+        const rating = parseSelfRating(response, 'technical_design');
+        assert.ok(rating);
+        assert.strictEqual(rating.score, 86);
+    });
+    void it('returns null for invalid score above 100', () => {
+        const response = JSON.stringify({
+            self_rating: {
+                score: 150,
+                summary: 'test',
+                criteria_scores: {},
+                strengths: [],
+                weaknesses: [],
+            },
+        });
+        const rating = parseSelfRating(response, 'technical_design');
+        assert.strictEqual(rating, null);
+    });
+    void it('returns null for negative score', () => {
+        const response = JSON.stringify({
+            self_rating: {
+                score: -5,
+                summary: 'test',
+                criteria_scores: {},
+                strengths: [],
+                weaknesses: [],
+            },
+        });
+        const rating = parseSelfRating(response, 'technical_design');
+        assert.strictEqual(rating, null);
+    });
+    void it('returns null for non-JSON response', () => {
+        const rating = parseSelfRating('This is not JSON at all', 'technical_design');
+        assert.strictEqual(rating, null);
+    });
+    void it('returns null for empty response', () => {
+        const rating = parseSelfRating('', 'technical_design');
+        assert.strictEqual(rating, null);
+    });
+    void it('handles missing optional fields gracefully', () => {
+        const response = JSON.stringify({
+            self_rating: {
+                score: 60,
+                criteria_scores: { completeness: { score: 60, reason: 'ok' } },
+            },
+        });
+        const rating = parseSelfRating(response, 'technical_design');
+        assert.ok(rating);
+        assert.strictEqual(rating.score, 60);
+        assert.strictEqual(rating.summary, '');
+        assert.deepStrictEqual(rating.strengths, []);
+        assert.deepStrictEqual(rating.weaknesses, []);
+        assert.strictEqual(rating.criteria_scores.completeness.score, 60);
+    });
+});

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