edsger 0.30.3 → 0.31.0

package/.claude/settings.local.json

@@ -1,28 +1,8 @@
 {
   "permissions": {
     "allow": [
-      "Read(//Users/steven/development/edsger/**)",
-      "Bash(npm run build)",
-      "Bash(node:*)",
-      "Bash(git add:*)",
-      "Bash(git commit:*)",
-      "Bash(ls:*)",
-      "Bash(cat:*)",
-      "Bash(npm run typecheck:*)",
-      "Bash(git diff:*)",
-      "WebSearch",
-      "WebFetch(domain:supabase.com)",
-      "Bash(npm install:*)",
-      "Bash(grep:*)",
-      "Bash(npx supabase gen types typescript --help:*)",
-      "Bash(git -C /Users/steven/development/edsger status)",
-      "Bash(git -C /Users/steven/development/edsger diff)",
-      "Bash(git -C /Users/steven/development/edsger log --oneline -5)",
-      "Bash(git -C /Users/steven/development/edsger add supabase/migrations/20251231000000_drop_unused_views.sql)",
-      "Bash(git -C /Users/steven/development/edsger commit -m \"$\\(cat <<''EOF''\nchore: drop unused database views\n\nRemove test_report_summary and user_stories_with_context views that are defined but never used in the application.\n\n🤖 Generated with [Claude Code]\\(https://claude.com/claude-code\\)\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")",
-      "Bash(git -C /Users/steven/development/edsger commit -m \"$\\(cat <<''EOF''\nchore: drop unused database views\n\nRemove test_report_summary and user_stories_with_context views\nthat are defined but never used in the application.\n\n🤖 Generated with [Claude Code]\\(https://claude.com/claude-code\\)\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")"
-    ],
-    "deny": [],
-    "ask": []
+      "Bash(npx tsc:*)",
+      "Bash(npm run:*)"
+    ]
   }
 }

package/dist/api/github.d.ts

@@ -39,6 +39,17 @@ export declare function getGitHubDeveloperConfig(featureId: string, verbose?: bo
  * Get installation access token for GitHub API operations
  */
 export declare function getGitHubInstallationToken(installationId: number, featureId: string, verbose?: boolean): Promise<GitHubInstallationToken | null>;
+/**
+ * Get GitHub config and token by product ID (no feature required).
+ * Used for product-level operations like growth analysis.
+ */
+export declare function getGitHubConfigByProduct(productId: string, verbose?: boolean): Promise<{
+    configured: boolean;
+    token?: string;
+    owner?: string;
+    repo?: string;
+    message?: string;
+}>;
 /**
  * Get GitHub config and token in one call
  * This is the main entry point for getting GitHub config

package/dist/api/github.js

@@ -59,6 +59,50 @@ export async function getGitHubInstallationToken(installationId, featureId, verb
         return null;
     }
 }
+/**
+ * Get GitHub config and token by product ID (no feature required).
+ * Used for product-level operations like growth analysis.
+ */
+export async function getGitHubConfigByProduct(productId, verbose) {
+    if (verbose) {
+        console.log(`🔍 Fetching GitHub config for product: ${productId}`);
+    }
+    try {
+        const result = (await callMcpEndpoint('github/config_and_token_by_product', {
+            product_id: productId,
+        }));
+        if (verbose) {
+            if (result.configured) {
+                console.log(`✅ GitHub ready: ${result.repository_full_name}`);
+            }
+            else {
+                console.log(`⚠️ GitHub not configured: ${result.message}`);
+            }
+        }
+        if (result.configured && result.token && result.owner && result.repo) {
+            return {
+                configured: true,
+                token: result.token,
+                owner: result.owner,
+                repo: result.repo,
+            };
+        }
+        return {
+            configured: false,
+            message: result.message ||
+                'GitHub not configured for this product. Set repo and developer_id in product settings.',
+        };
+    }
+    catch (error) {
+        if (verbose) {
+            console.error('❌ Failed to get GitHub config for product:', error);
+        }
+        return {
+            configured: false,
+            message: error instanceof Error ? error.message : 'Failed to get GitHub config',
+        };
+    }
+}
 /**
  * Get GitHub config and token in one call
  * This is the main entry point for getting GitHub config

package/dist/index.js

@@ -72,6 +72,25 @@ program
     }
 });
 // ============================================================
+// Subcommand: edsger growth <productId>
+// ============================================================
+program
+    .command('growth <productId>')
+    .description('Run AI-powered growth analysis for a product')
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (productId, opts) => {
+    try {
+        await runGrowthAnalysis({
+            growthAnalysis: productId,
+            verbose: opts.verbose,
+        });
+    }
+    catch (error) {
+        logError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// ============================================================
 // Default command (options-based, backward compatible)
 // ============================================================
 program
@@ -80,7 +99,6 @@ program
     .option('-f, --files <patterns...>', 'Review specific file patterns')
     .option('--refactor', 'Refactor code in current directory')
     .option('--init', 'Initialize .edsger directory with project templates')
-    .option('--growth-analysis <productId>', 'Run AI-powered growth analysis for a product')
     .option('--product-level', 'Use legacy product-level workflow (requires EDSGER_PRODUCT_ID, EDSGER_MCP_SERVER_URL, EDSGER_MCP_TOKEN env vars)')
     .option('--watch-tasks <productId>', 'Watch and execute pending tasks for a product')
     .option('--concurrency <number>', 'Max concurrent features to process (default: 3)', parseInt)
@@ -106,11 +124,6 @@ export const runEdsger = async (options) => {
         await runTaskWorker(options);
         return;
     }
-    // Handle growth analysis mode
-    if (options.growthAnalysis) {
-        await runGrowthAnalysis(options);
-        return;
-    }
     // Handle refactor mode
     if (options.refactor) {
         await runRefactor(options);

package/dist/phases/growth-analysis/agent.d.ts

@@ -1,2 +1,2 @@
 import { EdsgerConfig } from '../../types/index.js';
-export declare function executeGrowthAnalysisQuery(currentPrompt: string, systemPrompt: string, config: EdsgerConfig, verbose?: boolean): Promise<any | null>;
+export declare function executeGrowthAnalysisQuery(currentPrompt: string, systemPrompt: string, config: EdsgerConfig, verbose?: boolean, cwd?: string): Promise<any | null>;

package/dist/phases/growth-analysis/agent.js

@@ -38,7 +38,7 @@ function userMessage(content) {
 async function* prompt(analysisPrompt) {
     yield userMessage(analysisPrompt);
 }
-export async function executeGrowthAnalysisQuery(currentPrompt, systemPrompt, config, verbose) {
+export async function executeGrowthAnalysisQuery(currentPrompt, systemPrompt, config, verbose, cwd) {
     let lastAssistantResponse = '';
     let structuredResult = null;
     for await (const message of query({
@@ -52,6 +52,7 @@ export async function executeGrowthAnalysisQuery(currentPrompt, systemPrompt, co
             model: DEFAULT_MODEL,
             maxTurns: 1000,
             permissionMode: 'bypassPermissions',
+            ...(cwd ? { cwd } : {}),
         },
     })) {
         if (verbose) {

package/dist/phases/growth-analysis/context.d.ts

@@ -15,7 +15,7 @@ export declare function formatContextForPrompt(context: GrowthAnalysisContext):
 /**
  * Prepare the full analysis prompt with all context
  */
-export declare function prepareGrowthAnalysisContext(productId: string, verbose?: boolean): Promise<{
+export declare function prepareGrowthAnalysisContext(productId: string, verbose?: boolean, hasCodebase?: boolean): Promise<{
     context: GrowthAnalysisContext;
     analysisPrompt: string;
 }>;

package/dist/phases/growth-analysis/context.js

@@ -40,6 +40,11 @@ export function formatContextForPrompt(context) {
    Created: ${c.created_at}`)
             .join('\n\n')
         : 'No previous campaigns.';
+    const featuresList = product.features && product.features.length > 0
+        ? product.features
+            .map((f) => `- **${f.name}**: ${f.description || 'No description'} (Status: ${f.status || 'unknown'})`)
+            .join('\n')
+        : 'No features listed.';
     return `# Growth Analysis Context
 
 ## Product Information
@@ -47,22 +52,25 @@ export function formatContextForPrompt(context) {
 - **Product ID**: ${product.id}
 - **Description**: ${product.description || 'No description provided'}
 
+## Product Features (${product.features?.length || 0})
+${featuresList}
+
 ## Previous Growth Campaigns (${previousCampaigns.length})
 ${campaignsList}
 
 ---
 
-**Important**: Analyze the product above and create a growth strategy. Each content suggestion must be DIFFERENT from all previous campaigns listed above.`;
+**Important**: Analyze the product above and create a growth strategy. Each content suggestion must be DIFFERENT from all previous campaigns listed above. Use the product name, description, and features to write specific, concrete content — never use placeholder text.`;
 }
 /**
  * Prepare the full analysis prompt with all context
  */
-export async function prepareGrowthAnalysisContext(productId, verbose) {
+export async function prepareGrowthAnalysisContext(productId, verbose, hasCodebase = false) {
     if (verbose) {
         logInfo('Fetching growth analysis context via MCP endpoints...');
     }
     const context = await fetchGrowthAnalysisContext(productId, verbose);
     const contextInfo = formatContextForPrompt(context);
-    const analysisPrompt = createGrowthAnalysisPromptWithContext(productId, contextInfo);
+    const analysisPrompt = createGrowthAnalysisPromptWithContext(productId, contextInfo, hasCodebase);
     return { context, analysisPrompt };
 }

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

@@ -3,18 +3,41 @@ import { prepareGrowthAnalysisContext } from './context.js';
 import { createGrowthAnalysisSystemPrompt } from './prompts.js';
 import { executeGrowthAnalysisQuery } from './agent.js';
 import { saveGrowthAnalysis } from '../../api/growth.js';
+import { getGitHubConfigByProduct } from '../../api/github.js';
+import { ensureWorkspaceDir, cloneFeatureRepo, } from '../../workspace/workspace-manager.js';
 export const analyseGrowth = async (options, config) => {
     const { productId, verbose } = options;
     if (verbose) {
         logInfo(`Starting growth analysis for product ID: ${productId}`);
     }
     try {
-        const { context, analysisPrompt } = await prepareGrowthAnalysisContext(productId, verbose);
-        const systemPrompt = createGrowthAnalysisSystemPrompt();
+        // Clone product repo if GitHub is configured
+        let repoCwd;
+        try {
+            const githubConfig = await getGitHubConfigByProduct(productId, verbose);
+            if (githubConfig.configured &&
+                githubConfig.token &&
+                githubConfig.owner &&
+                githubConfig.repo) {
+                const workspaceRoot = ensureWorkspaceDir();
+                const { repoPath } = cloneFeatureRepo(workspaceRoot, `growth-${productId}`, githubConfig.owner, githubConfig.repo, githubConfig.token);
+                repoCwd = repoPath;
+                logInfo(`Repository cloned to: ${repoCwd}`);
+            }
+            else {
+                logInfo(`No GitHub repo configured for product, running without codebase access. ${githubConfig.message || ''}`);
+            }
+        }
+        catch (error) {
+            logInfo(`Could not clone repo (continuing without codebase): ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const hasCodebase = !!repoCwd;
+        const { context, analysisPrompt } = await prepareGrowthAnalysisContext(productId, verbose, hasCodebase);
+        const systemPrompt = createGrowthAnalysisSystemPrompt(hasCodebase);
         if (verbose) {
             logInfo('Starting AI query for growth analysis...');
         }
-        const analysisResult = await executeGrowthAnalysisQuery(analysisPrompt, systemPrompt, config, verbose);
+        const analysisResult = await executeGrowthAnalysisQuery(analysisPrompt, systemPrompt, config, verbose, repoCwd);
         if (!analysisResult) {
             throw new Error('No analysis results received');
         }

package/dist/phases/growth-analysis/prompts.d.ts

@@ -1,2 +1,2 @@
-export declare const createGrowthAnalysisSystemPrompt: () => string;
-export declare const createGrowthAnalysisPromptWithContext: (productId: string, contextInfo: string) => string;
+export declare const createGrowthAnalysisSystemPrompt: (hasCodebase?: boolean) => string;
+export declare const createGrowthAnalysisPromptWithContext: (productId: string, contextInfo: string, hasCodebase?: boolean) => string;

package/dist/phases/growth-analysis/prompts.js

@@ -1,14 +1,16 @@
-export const createGrowthAnalysisSystemPrompt = () => {
+export const createGrowthAnalysisSystemPrompt = (hasCodebase = false) => {
     return `You are an expert growth marketer and product strategist. Your task is to analyze a product and generate a comprehensive growth strategy with specific, actionable content recommendations for different channels.
 
 **Your Role**: Analyze the product, understand its target audience, review previous campaigns to avoid repetition, and create specific content pieces ready to be published on different platforms.
 
-**Analysis Process**:
-1. **Understand the Product**: Analyze the product's purpose, target audience, unique value proposition, and competitive positioning
-2. **Review Previous Campaigns**: Study past campaigns to understand what has been done, which channels were used, and avoid creating duplicate content
-3. **Research Current Trends**: Consider current industry trends, news, and timely topics relevant to the product
-4. **Identify Target Channels**: Recommend the best channels for growth based on the product's audience
-5. **Create Content Suggestions**: Generate specific, ready-to-publish content pieces for each recommended channel
+**Analysis Process**:${hasCodebase ? `
+1. **Explore the Codebase**: BEFORE writing any content, use your tools to explore the project's codebase. Read README files, CLAUDE.md, package.json, landing pages, documentation, and key source files to deeply understand what the product actually does, its features, technical architecture, and unique selling points. This is CRITICAL for writing specific, accurate content.
+2. **Understand the Product**: Based on your codebase exploration AND the provided context, build a complete picture of the product's purpose, target audience, unique value proposition, and competitive positioning` : `
+1. **Understand the Product**: Analyze the product's purpose, target audience, unique value proposition, and competitive positioning from the provided context`}
+${hasCodebase ? '3' : '2'}. **Review Previous Campaigns**: Study past campaigns to understand what has been done, which channels were used, and avoid creating duplicate content
+${hasCodebase ? '4' : '3'}. **Research Current Trends**: Consider current industry trends, news, and timely topics relevant to the product
+${hasCodebase ? '5' : '4'}. **Identify Target Channels**: Recommend the best channels for growth based on the product's audience
+${hasCodebase ? '6' : '5'}. **Create Content Suggestions**: Generate specific, ready-to-publish content pieces for each recommended channel${hasCodebase ? ', using real details from your codebase exploration' : ''}
 
 **Channel Expertise**:
 - Twitter/X: Short-form content, threads, engagement posts
@@ -30,6 +32,13 @@ export const createGrowthAnalysisSystemPrompt = () => {
 - Consider timing and relevance to current events
 - Content must be different from all previous campaigns
 
+**CRITICAL - NO PLACEHOLDERS**:
+- NEVER use placeholder brackets like [one-line value prop], [core problem], [link], [Screenshot], [Differentiator 1], etc.
+- ALL content must be fully written and ready to publish as-is
+- Use the actual product name, description, and features provided in the context to write concrete, specific content
+- If you don't have enough information for a detail (e.g., a URL or screenshot), either omit that part entirely or write around it naturally
+- The user should be able to copy-paste the content directly to the target platform without any edits
+
 **CRITICAL - Result Format**:
 You MUST return ONLY a JSON object. Do NOT include any text before or after the JSON.
 
@@ -67,22 +76,30 @@ You MUST return ONLY a JSON object. Do NOT include any text before or after the
 - Include a mix of content types (educational, promotional, community-building)
 - Consider the product's current stage and adjust strategy accordingly`;
 };
-export const createGrowthAnalysisPromptWithContext = (productId, contextInfo) => {
+export const createGrowthAnalysisPromptWithContext = (productId, contextInfo, hasCodebase = false) => {
+    const codebaseInstructions = hasCodebase
+        ? `
+**Step 1 - Explore the codebase FIRST**: Before writing anything, use your file reading and search tools to explore this project's codebase. Look at:
+- README.md, CLAUDE.md, package.json for project overview
+- Landing pages, marketing copy, or documentation for existing messaging
+- Key source files to understand what the product actually does technically
+- Any configuration or deployment files that reveal the tech stack
+
+**Step 2 - Analyze and create strategy**: Using your deep understanding from Step 1 plus the context above:`
+        : `
+**Analyze and create strategy**: Using the product context above:`;
     return `Please conduct comprehensive growth analysis for product ID: ${productId}
 
 ${contextInfo}
 
 ## Analysis Instructions
+${codebaseInstructions}
+1. Understand the product's real value proposition, target users, and competitive advantages
+2. Study the previous campaigns listed above - DO NOT suggest content that overlaps with what has already been published
+3. Identify the most effective channels for reaching this product's target audience
+4. Generate specific, ready-to-publish content pieces using REAL details${hasCodebase ? ' from the codebase (actual feature names, real technical details, concrete benefits)' : ' from the product context above'}
 
-Analyze the product above and create a growth strategy:
-
-1. **Product Analysis**: Understand the product's value proposition, target users, and competitive advantages
-2. **Previous Campaigns Review**: Study the previous campaigns listed above - DO NOT suggest content that overlaps with what has already been published
-3. **Channel Strategy**: Identify the most effective channels for reaching this product's target audience
-4. **Content Creation**: Generate specific, ready-to-publish content pieces for each recommended channel
-5. **Differentiation**: Ensure every suggested content piece is fresh and different from previous campaigns
-
-Focus on actionable, specific content that can be published immediately. Avoid generic advice.
+**CRITICAL**: Every content piece must be ready to copy-paste and publish. Use actual product details, not placeholders.
 
 Return ONLY the JSON response as specified in your instructions.`;
 };

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

@@ -70,19 +70,19 @@ export async function fetchPRExecutionContext(featureId, verbose) {
             logInfo(`Fetching PR execution context for feature: ${featureId}`);
         }
         const devBranchName = getDevBranchName(featureId);
+        // Fetch GitHub config and data in parallel (need token before remote branch check)
+        const [feature, pullRequests, githubConfig] = await Promise.all([
+            getFeature(featureId, verbose),
+            getPullRequests({ featureId, verbose }),
+            getGitHubConfig(featureId, verbose),
+        ]);
         // Verify dev branch exists
         const localExists = branchExists(devBranchName);
-        const remoteExists = !localExists && remoteBranchExists(devBranchName);
+        const remoteExists = !localExists && remoteBranchExists(devBranchName, githubConfig.token);
         if (!localExists && !remoteExists) {
             throw new Error(`Development branch '${devBranchName}' does not exist. ` +
                 `The feature must have code on the dev branch before PR execution.`);
         }
-        // Fetch GitHub config and data in parallel
-        const [feature, pullRequests, githubConfig] = await Promise.all([
-            getFeature(featureId, verbose),
-            getPullRequests({ featureId, verbose }),
-            getGitHubConfig(featureId, verbose),
-        ]);
         // If branch only exists on remote, fetch it (using credential helper)
         if (!localExists && remoteExists) {
             if (verbose) {

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

@@ -76,20 +76,20 @@ export async function fetchPRSplittingContext(featureId, verbose, replaceExistin
             logInfo(`Fetching PR splitting context for feature: ${featureId}`);
         }
         const devBranchName = getDevBranchName(featureId);
-        // Verify dev branch exists
-        const localExists = branchExists(devBranchName);
-        const remoteExists = !localExists && remoteBranchExists(devBranchName);
-        if (!localExists && !remoteExists) {
-            throw new Error(`Development branch '${devBranchName}' does not exist. ` +
-                `The feature must have code on the dev branch before PR splitting.`);
-        }
-        // Fetch database data and GitHub config in parallel
+        // Fetch database data and GitHub config in parallel (need token before remote branch check)
         const [feature, existing_branches, existing_pull_requests, githubConfig] = await Promise.all([
             getFeature(featureId, verbose),
             getBranches({ featureId, verbose }).catch(() => []),
             getPullRequests({ featureId, verbose }).catch(() => []),
             getGitHubConfig(featureId, verbose),
         ]);
+        // Verify dev branch exists
+        const localExists = branchExists(devBranchName);
+        const remoteExists = !localExists && remoteBranchExists(devBranchName, githubConfig.token);
+        if (!localExists && !remoteExists) {
+            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) {

package/dist/phases/pull-request/creator.js

@@ -3,8 +3,8 @@
  * Creates pull requests from feature branches after successful testing
  */
 import { Octokit } from '@octokit/rest';
-import { execSync } from 'child_process';
-import { gitPush } from '../../utils/git-push.js';
+import { execSync, execFileSync } from 'child_process';
+import { gitPush, buildCredentialArgs } from '../../utils/git-push.js';
 // GitHub PR title best practice: keep under 72 characters
 const MAX_PR_TITLE_LENGTH = 72;
 const PR_TITLE_PREFIX = 'feat: ';
@@ -67,7 +67,7 @@ const discardUncommittedChanges = (verbose) => {
  * @param branch - The branch to switch to
  * @param verbose - Whether to log verbose output
  */
-const switchToBranch = (branch, verbose) => {
+const switchToBranch = (branch, verbose, githubToken) => {
     try {
         // First check if branch exists locally
         if (!branchExists(branch)) {
@@ -77,7 +77,8 @@ const switchToBranch = (branch, verbose) => {
             }
             try {
                 // Fetch to get latest remote refs
-                execSync('git fetch origin', { encoding: 'utf-8', stdio: 'pipe' });
+                const credArgs = buildCredentialArgs(githubToken);
+                execFileSync('git', [...credArgs, 'fetch', 'origin'], { encoding: 'utf-8', stdio: 'pipe' });
                 // Check if remote branch exists
                 execSync(`git rev-parse --verify origin/${branch}`, {
                     encoding: 'utf-8',
@@ -230,7 +231,7 @@ export async function createPullRequest(config, feature) {
             if (verbose) {
                 console.log(`⚠️ Currently on ${baseBranch} branch, switching to ${devBranch}`);
             }
-            switchToBranch(devBranch, verbose);
+            switchToBranch(devBranch, verbose, githubToken);
             currentBranch = devBranch;
         }
         // Extract feature ID from current branch (dev/feature-id)

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