edsger 0.41.2 → 0.42.0

package/dist/phases/pr-resolve/checklist-learner.js

@@ -0,0 +1,128 @@
+/**
+ * Checklist Learner — runs after PR resolve to analyse addressed review
+ * comments and create / update code-review checklists so the same issues
+ * don't recur.
+ *
+ * Uses the Claude Agent SDK with the existing checklist MCP tools.
+ * Strictly non-blocking: failures only log a warning.
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { createChecklistsMcpServer } from '../../commands/checklists/tools.js';
+import { logInfo, logWarning } from '../../utils/logger.js';
+const LEARNER_SYSTEM_PROMPT = `You are a software quality engineer. Your task is to analyse review comments that were addressed during a PR resolve and distil them into actionable checklist items for the code_review phase.
+
+## Workflow
+
+1. **Read** the addressed review comments provided below.
+2. **Query existing checklists** using \`list_checklists\` with phase "code_review" to see what already exists.
+3. **Identify patterns** — group related comments into categories (e.g., error handling, naming, security, performance, testing).
+4. **Update or create checklist items**:
+   - If an existing checklist covers the category, add new items to it (skip if a similar item already exists).
+   - If no suitable checklist exists, create a new one.
+5. **Summarise** what you added or updated.
+
+## Rules
+
+- Only create items for **genuine quality patterns** — things that should be checked in every code review.
+- Skip one-off nits, purely stylistic preferences, or context-specific fixes that won't generalise.
+- Role: \`developer\`
+- Phases: \`["code_review"]\`
+- Item type: \`boolean\` (yes/no checkable)
+- Keep item titles concise (< 80 chars). Use the description for details.
+- Do NOT duplicate items that already exist in the checklists.
+- If all comments are too specific to generalise, it's fine to add nothing — just say so.
+`;
+/**
+ * Build a user prompt from the addressed review comments.
+ * @param addressedComments - pre-filtered list of comments with action === 'changed'
+ */
+export function buildLearnerPrompt(addressedComments, unresolvedThreads, commentIdToThreadId, summary) {
+    // Build a reverse lookup: threadId → thread for O(1) access
+    const threadById = new Map();
+    for (const thread of unresolvedThreads) {
+        threadById.set(thread.id, thread);
+    }
+    const sections = [
+        '# Addressed PR Review Comments',
+        '',
+        `${addressedComments.length} review comment(s) were accepted and fixed during PR resolution.`,
+        `Analyse these to identify patterns that should become checklist items for future code reviews.`,
+        '',
+    ];
+    for (const comment of addressedComments) {
+        const threadId = commentIdToThreadId.get(comment.comment_id);
+        const thread = threadId ? threadById.get(threadId) : undefined;
+        const firstNode = thread?.comments.nodes[0];
+        sections.push(`## ${comment.comment_id}`);
+        if (firstNode) {
+            sections.push(`**File**: ${firstNode.path}`);
+            if (firstNode.line) {
+                sections.push(`**Line**: ${firstNode.line}`);
+            }
+            sections.push(`**Reviewer**: @${firstNode.author.login}`);
+            sections.push(`**Review comment**:`);
+            sections.push(firstNode.body);
+        }
+        sections.push(`**Resolution**: ${comment.reply}`);
+        sections.push('');
+    }
+    if (summary) {
+        sections.push('## Overall Summary');
+        sections.push(summary);
+        sections.push('');
+    }
+    sections.push('## Instructions');
+    sections.push('Based on the patterns above, query existing code_review checklists and create or update items to prevent these issues from recurring.');
+    return sections.join('\n');
+}
+/**
+ * Analyse addressed review comments and update code-review checklists.
+ * Non-blocking — catches all errors and logs a warning.
+ */
+export async function learnFromReviewFeedback(input) {
+    try {
+        const { resolveResult, unresolvedThreads, commentIdToThreadId, verbose, productId, } = input;
+        // Filter once — only learn from accepted changes
+        const addressedComments = resolveResult.comments.filter((c) => c.action === 'changed');
+        if (addressedComments.length === 0) {
+            if (verbose) {
+                logInfo('No addressed comments to learn from, skipping checklist sync.');
+            }
+            return;
+        }
+        logInfo(`Learning from ${addressedComments.length} addressed review comment(s) to update checklists...`);
+        const userPrompt = buildLearnerPrompt(addressedComments, unresolvedThreads, commentIdToThreadId, resolveResult.summary);
+        const mcpServer = createChecklistsMcpServer(productId);
+        for await (const message of query({
+            prompt: userPrompt,
+            options: {
+                systemPrompt: {
+                    type: 'preset',
+                    preset: 'claude_code',
+                    append: LEARNER_SYSTEM_PROMPT,
+                },
+                model: 'sonnet',
+                maxTurns: 15,
+                permissionMode: 'bypassPermissions',
+                mcpServers: {
+                    'edsger-checklists': mcpServer,
+                },
+            },
+        })) {
+            if (message.type === 'result') {
+                if (message.subtype === 'success') {
+                    logInfo('Checklist learning completed.');
+                    if (verbose && message.result) {
+                        logInfo(message.result);
+                    }
+                }
+                else if (verbose) {
+                    logWarning(`Checklist learning incomplete: ${message.subtype}`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        logWarning(`Checklist learning failed (non-blocking): ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/phases/pr-resolve/index.d.ts

@@ -11,6 +11,8 @@ export interface StandalonePRResolveOptions {
     repo: string;
     prId?: string;
     verbose?: boolean;
+    /** Set to false to skip checklist learning after resolve (default: true) */
+    learn?: boolean;
 }
 export interface PRResolveResult {
     status: 'success' | 'error';
@@ -21,6 +23,8 @@ export interface PRResolveResult {
     filesModified?: string[];
     summary?: string;
 }
+export type { ResolveComment, ResolveResult } from './types.js';
+export { isResolveResult } from './types.js';
 /**
  * Resolve PR change requests: evaluate each comment, fix or explain.
  */

package/dist/phases/pr-resolve/index.js

@@ -13,9 +13,12 @@ import { logError, logInfo, logSuccess } from '../../utils/logger.js';
 import { fetchUnresolvedReviewThreads } from '../code-refine-verification/github.js';
 import { createPromptGenerator, extractTextFromContent, tryExtractResult, } from '../pr-shared/agent-utils.js';
 import { parsePullRequestUrl } from '../pr-shared/context.js';
+import { learnFromReviewFeedback } from './checklist-learner.js';
 import { replyToReviewThread, resolveReviewThread } from './github-reply.js';
 import { createResolveSystemPrompt, createResolveUserPrompt, } from './prompts.js';
+import { isResolveResult } from './types.js';
 import { hasNewCommits, hasUncommittedChanges, prepareWorkspace, pushChanges, } from './workspace.js';
+export { isResolveResult } from './types.js';
 /**
  * Resolve PR change requests: evaluate each comment, fix or explain.
  */
@@ -57,7 +60,6 @@ export async function resolveStandalonePR(options) {
             const systemPrompt = createResolveSystemPrompt();
             const { prompt: resolvePrompt, commentIdToThreadId } = createResolveUserPrompt(unresolvedThreads);
             let lastAssistantResponse = '';
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             let resolveResult = null;
             logInfo('Starting Claude agent to evaluate and resolve comments...');
             for await (const message of query({
@@ -84,8 +86,11 @@ export async function resolveStandalonePR(options) {
                 if (message.subtype === 'success') {
                     logInfo('Agent completed, parsing results...');
                     const responseText = message.result || lastAssistantResponse;
-                    resolveResult = tryExtractResult(responseText, 'resolve_result');
-                    if (!resolveResult) {
+                    const parsed = tryExtractResult(responseText, 'resolve_result');
+                    if (isResolveResult(parsed)) {
+                        resolveResult = parsed;
+                    }
+                    else {
                         logError('Failed to parse resolve result JSON');
                     }
                 }
@@ -93,7 +98,10 @@ export async function resolveStandalonePR(options) {
                     logError(`Agent incomplete: ${message.subtype}`);
                     // Try to salvage partial results from last response
                     if (lastAssistantResponse) {
-                        resolveResult = tryExtractResult(lastAssistantResponse, 'resolve_result');
+                        const salvaged = tryExtractResult(lastAssistantResponse, 'resolve_result');
+                        if (isResolveResult(salvaged)) {
+                            resolveResult = salvaged;
+                        }
                     }
                 }
             }
@@ -113,7 +121,7 @@ export async function resolveStandalonePR(options) {
             let threadsSkipped = 0;
             let threadsErrored = 0;
             if (resolveResult?.comments) {
-                const comments = resolveResult.comments;
+                const { comments } = resolveResult;
                 for (const comment of comments) {
                     // Map comment_id back to real GraphQL thread ID
                     const threadId = commentIdToThreadId.get(comment.comment_id);
@@ -166,6 +174,16 @@ export async function resolveStandalonePR(options) {
                 }
             }
             logSuccess(`PR resolve completed: ${threadsAddressed} addressed, ${threadsSkipped} skipped, ${threadsErrored} errors`);
+            // Learn from addressed comments to update code-review checklists
+            if (options.learn !== false && threadsAddressed > 0 && resolveResult) {
+                await learnFromReviewFeedback({
+                    productId: options.productId,
+                    unresolvedThreads,
+                    resolveResult,
+                    commentIdToThreadId,
+                    verbose,
+                });
+            }
             if (prId) {
                 try {
                     await callMcpEndpoint('pull_requests/update', {

package/dist/phases/pr-resolve/prompts.js

@@ -73,8 +73,9 @@ export function createResolveUserPrompt(unresolvedThreads) {
     let commentIndex = 0;
     for (const thread of unresolvedThreads) {
         const firstComment = thread.comments.nodes[0];
-        if (!firstComment)
+        if (!firstComment) {
             continue;
+        }
         commentIndex++;
         const commentId = `comment_${commentIndex}`;
         commentIdToThreadId.set(commentId, thread.id);

package/dist/phases/pr-resolve/types.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Shared type definitions for PR resolve phase.
+ */
+export interface ResolveComment {
+    comment_id: string;
+    action: 'changed' | 'skipped';
+    reply: string;
+}
+export interface ResolveResult {
+    comments: ResolveComment[];
+    files_modified?: string[];
+    summary?: string;
+}
+/**
+ * Runtime type guard — validates that an unknown value from tryExtractResult
+ * has the shape of a ResolveResult.
+ */
+export declare function isResolveResult(value: unknown): value is ResolveResult;

package/dist/phases/pr-resolve/types.js

@@ -0,0 +1,14 @@
+/**
+ * Shared type definitions for PR resolve phase.
+ */
+/**
+ * Runtime type guard — validates that an unknown value from tryExtractResult
+ * has the shape of a ResolveResult.
+ */
+export function isResolveResult(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const obj = value;
+    return Array.isArray(obj.comments);
+}

package/dist/phases/pr-resolve/workspace.d.ts

@@ -18,7 +18,7 @@ export declare function prepareWorkspace(owner: string, repo: string, headRef: s
 /**
  * Push changes from workspace back to remote.
  */
-export declare function pushChanges(repoPath: string, headRef: string, token: string, verbose?: boolean): boolean;
+export declare function pushChanges(repoPath: string, headRef: string, token: string, _verbose?: boolean): boolean;
 /**
  * Check if there are uncommitted changes in the workspace.
  */

package/dist/phases/pr-resolve/workspace.js

@@ -98,7 +98,7 @@ export function prepareWorkspace(owner, repo, headRef, prNumber, token, verbose)
 /**
  * Push changes from workspace back to remote.
  */
-export function pushChanges(repoPath, headRef, token, verbose) {
+export function pushChanges(repoPath, headRef, token, _verbose) {
     const gitCredentialArgs = buildCredentialArgs(token);
     try {
         execFileSync('git', [...gitCredentialArgs, 'push', 'origin', headRef], {

package/dist/phases/pr-review/__tests__/review-comments.test.js

@@ -17,11 +17,13 @@ function mapCommentsToReviewPayload(agentComments, files) {
     const result = [];
     for (const comment of agentComments) {
         const lineToPosition = fileLineToPosition.get(comment.file);
-        if (!lineToPosition)
+        if (!lineToPosition) {
             continue;
+        }
         const positionResult = findClosestPosition(comment.line, lineToPosition);
-        if (!positionResult)
+        if (!positionResult) {
             continue;
+        }
         let body = comment.comment;
         if (positionResult.actualLine !== comment.line) {
             body = `**Note**: Comment originally for line ${comment.line}, adjusted to line ${positionResult.actualLine} (nearest line in diff).\n\n${body}`;

package/dist/phases/pr-review/index.js

@@ -14,9 +14,7 @@ import { createStandaloneReviewSystemPrompt, createStandaloneReviewUserPrompt, }
 /**
  * Review a standalone PR and post comments to GitHub.
  */
-export async function reviewStandalonePR(options
-// eslint-disable-next-line complexity
-) {
+export async function reviewStandalonePR(options) {
     const { pullRequestUrl, githubToken, verbose, prId } = options;
     logInfo(`Starting standalone PR review: ${pullRequestUrl}`);
     try {

package/dist/phases/pr-shared/agent-utils.js

@@ -24,7 +24,6 @@ export async function* createPromptGenerator(prompt) {
 /**
  * Extract text content from assistant message content array.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function extractTextFromContent(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 content, verbose) {

package/dist/phases/pr-shared/context.d.ts

@@ -3,8 +3,8 @@
  * Reuses GitHub API utilities from code-review/context.ts without feature dependencies.
  */
 import { type PRCommit, type PRData, type PRFile } from '../code-review/context.js';
-export { parsePullRequestUrl } from '../code-review/context.js';
 export type { PRCommit, PRData, PRFile } from '../code-review/context.js';
+export { parsePullRequestUrl } from '../code-review/context.js';
 export interface StandalonePRContext {
     pullRequestUrl: string;
     pullRequestNumber: number;

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/phases/pr-splitting/index.js

@@ -27,9 +27,7 @@ async function* prompt(analysisPrompt) {
  * then uses AI to produce a PR split plan saved to the database.
  * Human review is expected before running the pr-execution phase.
  */
-export const splitFeatureIntoPRs = async (options, config
-// eslint-disable-next-line complexity -- orchestration function with context fetching, agent execution, and result processing
-) => {
+export const splitFeatureIntoPRs = async (options, config) => {
     const { featureId, verbose, replaceExisting } = options;
     if (verbose) {
         logInfo(`Starting PR splitting for feature ID: ${featureId}`);

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

@@ -24,9 +24,7 @@ async function* prompt(analysisPrompt) {
         setTimeout(res, 10000);
     });
 }
-export const generateTechnicalDesign = async (options, config, checklistContext
-// eslint-disable-next-line complexity -- orchestration function with context assembly, design generation, and verification
-) => {
+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,7 @@ 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 -- orchestration function with context assembly, agent execution, and result processing
-) => {
+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,7 @@ 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 -- orchestration function with context assembly, agent execution, and result processing
-) => {
+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/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 {};