edsger 0.19.10 → 0.19.11

package/dist/phases/code-refine/index.js

@@ -11,7 +11,7 @@ import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services
 import { createSystemPrompt, createCodeRefinePrompt } from './prompts.js';
 import { preparePhaseGitEnvironment, prepareCustomBranchGitEnvironment, hasUncommittedChanges, getUncommittedFiles, syncFeatBranchWithMain, } from '../../utils/git-branch-manager.js';
 import { getFeature } from '../../api/features/get-feature.js';
-import { getReadyForReviewBranch, } from '../../services/branches.js';
+import { getReviewedBranch, updateBranch, } from '../../services/branches.js';
 import { parsePullRequestUrl } from './context.js';
 import { verifyAndResolveComments, } from '../code-refine-verification/index.js';
 // Maximum number of refine + verification iterations
@@ -71,22 +71,22 @@ export const refineCodeFromPRFeedback = async (options, config) => {
     if (verbose) {
         logInfo(`Starting code refine for feature ID: ${featureId}`);
     }
-    // For multi-branch features, find the branch that is ready for review
-    // and use its branch_name for refine (branch_name is stored as dev/...)
+    // For multi-branch features, find the branch that has been reviewed
+    // (status = 'reviewed' after code-review phase) and use its branch_name for refine
     let branchName = `dev/${featureId}`; // Default for single-branch features
     let currentBranch = null;
     try {
-        currentBranch = await getReadyForReviewBranch({ featureId, verbose });
+        currentBranch = await getReviewedBranch({ featureId, verbose });
         if (currentBranch && currentBranch.branch_name) {
             // Use branch_name directly (already stored as dev/...)
             branchName = currentBranch.branch_name;
             if (verbose) {
-                logInfo(`📋 Found ready_for_review branch: ${currentBranch.name}`);
+                logInfo(`📋 Found reviewed branch: ${currentBranch.name}`);
                 logInfo(`   Using dev branch: ${branchName}`);
             }
         }
         else if (verbose) {
-            logInfo(`ℹ️ No ready_for_review branch found, using default: ${branchName}`);
+            logInfo(`ℹ️ No reviewed branch found, using default: ${branchName}`);
         }
     }
     catch (error) {
@@ -232,11 +232,19 @@ Please ensure Claude Code commits all changes before completing the refine phase
                 if (verbose) {
                     logInfo('✅ Verification passed! All PR comments have been addressed and resolved.');
                 }
+                // Update branch status to 'refined' for multi-branch features
+                if (currentBranch) {
+                    await updateBranch(currentBranch.id, { status: 'refined' }, verbose);
+                    if (verbose) {
+                        logInfo(`✅ Branch "${currentBranch.name}" status updated to 'refined'`);
+                    }
+                }
                 return {
                     featureId,
                     status: 'success',
                     message: verificationResult.message,
-                    summary: lastRefineResult.summary || 'Code refined based on PR review feedback',
+                    summary: lastRefineResult.summary ||
+                        'Code refined based on PR review feedback',
                     filesModified: lastRefineResult.files_modified || [],
                     commitsCreated: lastRefineResult.commits_created || 1,
                     iterations: currentIteration,
@@ -277,7 +285,8 @@ Please ensure Claude Code commits all changes before completing the refine phase
         return {
             featureId,
             status: 'error',
-            message: lastVerificationResult?.message || 'Verification failed after max iterations',
+            message: lastVerificationResult?.message ||
+                'Verification failed after max iterations',
             summary: lastRefineResult?.summary,
             filesModified: lastRefineResult?.files_modified || [],
             commitsCreated: lastRefineResult?.commits_created || 1,

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

@@ -8,7 +8,7 @@ import { Octokit } from '@octokit/rest';
 import { fetchCodeReviewContext, formatContextForPrompt, } from './context.js';
 import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 import { preparePhaseGitEnvironment, prepareCustomBranchGitEnvironment, } from '../../utils/git-branch-manager.js';
-import { getReadyForReviewBranch, } from '../../services/branches.js';
+import { getReadyForReviewBranch, updateBranch, } from '../../services/branches.js';
 import { getFeature } from '../../api/features/get-feature.js';
 function userMessage(content) {
     return {
@@ -319,6 +319,13 @@ export const reviewPullRequest = async (options, config) => {
                         overall_assessment ||
                         'Code review completed. No issues found.',
                 });
+                // Update branch status to 'reviewed' for multi-branch features
+                if (currentBranch) {
+                    await updateBranch(currentBranch.id, { status: 'reviewed' }, verbose);
+                    if (verbose) {
+                        logInfo(`✅ Branch "${currentBranch.name}" status updated to 'reviewed'`);
+                    }
+                }
                 return {
                     featureId,
                     status: 'success',
@@ -389,6 +396,13 @@ export const reviewPullRequest = async (options, config) => {
                     body: (summary || overall_assessment || 'Code review completed.') +
                         '\n\n**Note**: Some review comments could not be posted because they referenced lines not present in the diff.',
                 });
+                // Update branch status to 'reviewed' for multi-branch features
+                if (currentBranch) {
+                    await updateBranch(currentBranch.id, { status: 'reviewed' }, verbose);
+                    if (verbose) {
+                        logInfo(`✅ Branch "${currentBranch.name}" status updated to 'reviewed'`);
+                    }
+                }
                 return {
                     featureId,
                     status: 'success',
@@ -418,6 +432,13 @@ export const reviewPullRequest = async (options, config) => {
                 logInfo(`Review ID: ${review.data.id}`);
                 logInfo(`Comments posted: ${comments.length}`);
             }
+            // Update branch status to 'reviewed' for multi-branch features
+            if (currentBranch) {
+                await updateBranch(currentBranch.id, { status: 'reviewed' }, verbose);
+                if (verbose) {
+                    logInfo(`✅ Branch "${currentBranch.name}" status updated to 'reviewed'`);
+                }
+            }
             return {
                 featureId,
                 status: 'success',

package/dist/services/branches.d.ts

@@ -12,7 +12,7 @@ export interface Branch {
     base_branch_id: string | null;
     pull_request_url: string | null;
     pull_request_number: number | null;
-    status: 'pending' | 'in_progress' | 'ready_for_review' | 'merged' | 'closed';
+    status: 'pending' | 'in_progress' | 'ready_for_review' | 'reviewed' | 'refined' | 'merged' | 'closed';
     created_at: string;
     updated_at: string;
 }
@@ -80,6 +80,11 @@ export declare function getBranchById(branchId: string, verbose?: boolean): Prom
  * Returns the first branch with status 'ready_for_review'
  */
 export declare function getReadyForReviewBranch(options: PipelinePhaseOptions): Promise<Branch | null>;
+/**
+ * Get the branch that has been reviewed (for code-refine phase)
+ * Returns the first branch with status 'reviewed'
+ */
+export declare function getReviewedBranch(options: PipelinePhaseOptions): Promise<Branch | null>;
 /**
  * Get the branch that is in progress (in_progress or ready_for_review)
  * Useful for phases that need to work on the current active branch

package/dist/services/branches.js

@@ -95,17 +95,28 @@ export function formatBranchesForContext(branches) {
     if (!branches || branches.length === 0) {
         return 'No branches defined yet.';
     }
+    const getStatusEmoji = (status) => {
+        switch (status) {
+            case 'merged':
+                return '✅';
+            case 'refined':
+                return '🎯';
+            case 'reviewed':
+                return '📝';
+            case 'ready_for_review':
+                return '👀';
+            case 'in_progress':
+                return '🔄';
+            case 'closed':
+                return '❌';
+            case 'pending':
+            default:
+                return '⏳';
+        }
+    };
     const branchList = branches
         .map((b, idx) => {
-        const statusEmoji = b.status === 'merged'
-            ? '✅'
-            : b.status === 'in_progress'
-                ? '🔄'
-                : b.status === 'ready_for_review'
-                    ? '👀'
-                    : b.status === 'closed'
-                        ? '❌'
-                        : '⏳';
+        const statusEmoji = getStatusEmoji(b.status);
         return `${idx + 1}. **${b.name}** ${statusEmoji}
    - Status: ${b.status}
    - Branch: ${b.branch_name || 'Not created'}
@@ -211,6 +222,14 @@ export async function getReadyForReviewBranch(options) {
     const branches = await getBranches(options);
     return branches.find((b) => b.status === 'ready_for_review') || null;
 }
+/**
+ * Get the branch that has been reviewed (for code-refine phase)
+ * Returns the first branch with status 'reviewed'
+ */
+export async function getReviewedBranch(options) {
+    const branches = await getBranches(options);
+    return branches.find((b) => b.status === 'reviewed') || null;
+}
 /**
  * Get the branch that is in progress (in_progress or ready_for_review)
  * Useful for phases that need to work on the current active branch

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.19.10",
+  "version": "0.19.11",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"

package/.claude/settings.local.json

@@ -1,28 +0,0 @@
-{
-  "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": []
-  }
-}

package/dist/api/features/__tests__/regression-prevention.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Specialized tests for status regression prevention
- * Focuses on the core business requirement: preventing backward status movement
- */
-export {};

package/dist/api/features/__tests__/regression-prevention.test.js

@@ -1,338 +0,0 @@
-/**
- * Specialized tests for status regression prevention
- * Focuses on the core business requirement: preventing backward status movement
- */
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-import { isForwardProgression } from '../status-updater.js';
-import { STATUS_PROGRESSION_ORDER } from '../../../config/feature-status.js';
-describe('Regression Prevention Tests', () => {
-    describe('Core Business Logic: Prevent Backlog Regression', () => {
-        it('should prevent any status from regressing to backlog', () => {
-            const allStatuses = STATUS_PROGRESSION_ORDER.slice(1); // All except backlog itself
-            for (const status of allStatuses) {
-                const result = isForwardProgression(status, 'backlog');
-                assert.strictEqual(result, false, `Status ${status} should NOT be allowed to regress to backlog`);
-            }
-        });
-        it('should allow progression from backlog to any other status', () => {
-            const targetStatuses = STATUS_PROGRESSION_ORDER.slice(1); // All except backlog
-            for (const targetStatus of targetStatuses) {
-                const result = isForwardProgression('backlog', targetStatus);
-                assert.strictEqual(result, true, `Should allow progression from backlog to ${targetStatus}`);
-            }
-        });
-        it('should prevent regression from any status to ready_for_dev', () => {
-            // Only backlog should be allowed to progress to ready_for_dev
-            const higherStatuses = STATUS_PROGRESSION_ORDER.slice(2); // All except backlog and ready_for_dev
-            for (const status of higherStatuses) {
-                const result = isForwardProgression(status, 'ready_for_dev');
-                assert.strictEqual(result, false, `Status ${status} should NOT regress to ready_for_dev`);
-            }
-        });
-        it('should prevent all forms of backward progression in critical workflow', () => {
-            // Test critical workflow progression points
-            const criticalProgression = [
-                'backlog',
-                'ready_for_dev',
-                'feature_analysis',
-                'technical_design',
-                'code_implementation',
-                'functional_testing',
-                'deployment',
-                'shipped',
-            ];
-            // Test every possible backward combination
-            for (let i = 0; i < criticalProgression.length; i++) {
-                for (let j = 0; j < i; j++) {
-                    const currentStatus = criticalProgression[i];
-                    const targetStatus = criticalProgression[j];
-                    const result = isForwardProgression(currentStatus, targetStatus);
-                    assert.strictEqual(result, false, `Should prevent regression from ${currentStatus} to ${targetStatus}`);
-                }
-            }
-        });
-    });
-    describe('CLI Phase Protection', () => {
-        it('should identify scenarios where CLI phases could cause regression', () => {
-            // Simulate CLI phases that could potentially cause issues
-            const problematicScenarios = [
-                {
-                    currentStatus: 'code_implementation',
-                    phase: 'feature-analysis',
-                    expectedTargetStatus: 'feature_analysis',
-                    description: 'CLI re-running feature analysis after code implementation',
-                },
-                {
-                    currentStatus: 'deployment',
-                    phase: 'technical-design',
-                    expectedTargetStatus: 'technical_design',
-                    description: 'CLI running technical design after deployment',
-                },
-                {
-                    currentStatus: 'shipped',
-                    phase: 'code-implementation',
-                    expectedTargetStatus: 'code_implementation',
-                    description: 'CLI attempting code implementation on shipped feature',
-                },
-                {
-                    currentStatus: 'testing_passed',
-                    phase: 'feature-analysis',
-                    expectedTargetStatus: 'feature_analysis',
-                    description: 'CLI re-analyzing feature after tests passed',
-                },
-            ];
-            for (const scenario of problematicScenarios) {
-                const result = isForwardProgression(scenario.currentStatus, scenario.expectedTargetStatus);
-                assert.strictEqual(result, false, `Regression prevention should block: ${scenario.description}`);
-            }
-        });
-        it('should allow valid CLI phase progressions', () => {
-            const validScenarios = [
-                {
-                    currentStatus: 'backlog',
-                    phase: 'feature-analysis',
-                    expectedTargetStatus: 'feature_analysis',
-                    description: 'CLI starting feature analysis from backlog',
-                },
-                {
-                    currentStatus: 'feature_analysis',
-                    phase: 'technical-design',
-                    expectedTargetStatus: 'technical_design',
-                    description: 'CLI progressing to technical design',
-                },
-                {
-                    currentStatus: 'technical_design',
-                    phase: 'code-implementation',
-                    expectedTargetStatus: 'code_implementation',
-                    description: 'CLI progressing to code implementation',
-                },
-                {
-                    currentStatus: 'functional_testing',
-                    phase: 'deployment',
-                    expectedTargetStatus: 'deployment',
-                    description: 'CLI progressing to deployment after testing',
-                },
-            ];
-            for (const scenario of validScenarios) {
-                const result = isForwardProgression(scenario.currentStatus, scenario.expectedTargetStatus);
-                assert.strictEqual(result, true, `Valid progression should be allowed: ${scenario.description}`);
-            }
-        });
-    });
-    describe('Edge Cases and Boundary Conditions', () => {
-        it('should handle same-status transitions correctly', () => {
-            // Allow staying at the same status (for retries, re-runs, etc.)
-            for (const status of STATUS_PROGRESSION_ORDER) {
-                const result = isForwardProgression(status, status);
-                assert.strictEqual(result, true, `Should allow staying at status ${status}`);
-            }
-        });
-        it('should handle first and last status edge cases', () => {
-            const firstStatus = STATUS_PROGRESSION_ORDER[0]; // 'backlog'
-            const lastStatus = STATUS_PROGRESSION_ORDER[STATUS_PROGRESSION_ORDER.length - 1]; // 'shipped'
-            // From first to last should be allowed
-            const forwardResult = isForwardProgression(firstStatus, lastStatus);
-            assert.strictEqual(forwardResult, true, 'Should allow progression from first to last status');
-            // From last to first should be prevented
-            const backwardResult = isForwardProgression(lastStatus, firstStatus);
-            assert.strictEqual(backwardResult, false, 'Should prevent regression from last to first status');
-        });
-        it('should validate progression order is strictly enforced', () => {
-            // Test every adjacent pair in the progression
-            for (let i = 0; i < STATUS_PROGRESSION_ORDER.length - 1; i++) {
-                const currentStatus = STATUS_PROGRESSION_ORDER[i];
-                const nextStatus = STATUS_PROGRESSION_ORDER[i + 1];
-                // Forward should be allowed
-                const forwardResult = isForwardProgression(currentStatus, nextStatus);
-                assert.strictEqual(forwardResult, true, `Should allow progression from ${currentStatus} to ${nextStatus}`);
-                // Backward should be prevented
-                const backwardResult = isForwardProgression(nextStatus, currentStatus);
-                assert.strictEqual(backwardResult, false, `Should prevent regression from ${nextStatus} to ${currentStatus}`);
-            }
-        });
-        it('should handle testing workflow regression scenarios', () => {
-            // Testing has special rules - test specific edge cases
-            const testingScenarios = [
-                {
-                    from: 'testing_passed',
-                    to: 'testing_in_progress',
-                    shouldAllow: false,
-                    description: 'Should prevent going back from passed to in-progress',
-                },
-                {
-                    from: 'testing_passed',
-                    to: 'testing_failed',
-                    shouldAllow: true,
-                    description: 'Should allow going from passed to failed (possible if retested)',
-                },
-                {
-                    from: 'testing_failed',
-                    to: 'testing_passed',
-                    shouldAllow: false,
-                    description: 'Should prevent going from failed to passed (need to restart testing)',
-                },
-                {
-                    from: 'testing_in_progress',
-                    to: 'testing_failed',
-                    shouldAllow: true,
-                    description: 'Should allow marking in-progress tests as failed',
-                },
-                {
-                    from: 'testing_in_progress',
-                    to: 'testing_passed',
-                    shouldAllow: true,
-                    description: 'Should allow marking in-progress tests as passed',
-                },
-            ];
-            for (const scenario of testingScenarios) {
-                const result = isForwardProgression(scenario.from, scenario.to);
-                assert.strictEqual(result, scenario.shouldAllow, scenario.description);
-            }
-        });
-        it('should prevent skipping multiple phases backwards', () => {
-            // Test skipping multiple phases in regression
-            const skipBackwardTests = [
-                {
-                    from: 'shipped',
-                    to: 'feature_analysis',
-                    skipCount: 'many phases',
-                },
-                {
-                    from: 'code_implementation',
-                    to: 'backlog',
-                    skipCount: 'many phases',
-                },
-                {
-                    from: 'deployment',
-                    to: 'ready_for_dev',
-                    skipCount: 'many phases',
-                },
-            ];
-            for (const test of skipBackwardTests) {
-                const result = isForwardProgression(test.from, test.to);
-                assert.strictEqual(result, false, `Should prevent skipping ${test.skipCount} backwards from ${test.from} to ${test.to}`);
-            }
-        });
-        it('should allow skipping multiple phases forward', () => {
-            // Test skipping phases in forward direction (should be allowed)
-            const skipForwardTests = [
-                {
-                    from: 'backlog',
-                    to: 'code_implementation',
-                    description: 'Skip from backlog to code implementation',
-                },
-                {
-                    from: 'feature_analysis',
-                    to: 'deployment',
-                    description: 'Skip from analysis to deployment',
-                },
-                {
-                    from: 'technical_design',
-                    to: 'shipped',
-                    description: 'Skip from design to shipped',
-                },
-            ];
-            for (const test of skipForwardTests) {
-                const result = isForwardProgression(test.from, test.to);
-                assert.strictEqual(result, true, `Should allow forward skip: ${test.description}`);
-            }
-        });
-    });
-    describe('Real-world Workflow Scenarios', () => {
-        it('should handle hotfix scenario correctly', () => {
-            // Hotfix: shipped feature needs bug fixing
-            // Should allow progression to bug_fixing from shipped
-            const result = isForwardProgression('shipped', 'bug_fixing');
-            // Since bug_fixing comes before shipped in progression, this should be false
-            assert.strictEqual(result, false, 'Should prevent regression from shipped to bug_fixing (hotfixes need new feature entries)');
-        });
-        it('should handle feature refinement scenarios', () => {
-            // Feature refinement: going from code_implementation to code_refine
-            const result1 = isForwardProgression('code_implementation', 'code_refine');
-            assert.strictEqual(result1, true, 'Should allow progression from implementation to refinement');
-            // But not the other way around
-            const result2 = isForwardProgression('code_refine', 'code_implementation');
-            assert.strictEqual(result2, false, 'Should prevent regression from refinement to implementation');
-        });
-        it('should handle review cycle scenarios', () => {
-            // Review cycles: code_review -> pull_request -> code_review (if rejected)
-            const reviewToPrep = isForwardProgression('code_review', 'pull_request');
-            assert.strictEqual(reviewToPrep, true, 'Should allow progression from review to pull request');
-            // But not back from pull_request to code_review
-            const prepToReview = isForwardProgression('pull_request', 'code_review');
-            assert.strictEqual(prepToReview, false, 'Should prevent regression from pull request to code review');
-        });
-        it('should handle deployment rollback scenarios', () => {
-            // Deployment rollback: deployment -> functional_testing (to re-test)
-            const deployToTest = isForwardProgression('deployment', 'functional_testing');
-            assert.strictEqual(deployToTest, false, 'Should prevent regression from deployment to testing (rollbacks need new process)');
-        });
-        it('should validate complete workflow progression path', () => {
-            // Simulate a complete feature lifecycle
-            const completeWorkflow = [
-                'backlog',
-                'ready_for_dev',
-                'feature_analysis',
-                'feature_analysis_verification',
-                'technical_design',
-                'technical_design_verification',
-                'code_implementation',
-                'code_refine',
-                'code_review',
-                'pull_request',
-                'functional_testing',
-                'testing_in_progress',
-                'testing_passed',
-                'deployment',
-                'shipped',
-            ];
-            // Test each step in the workflow
-            for (let i = 0; i < completeWorkflow.length - 1; i++) {
-                const currentStatus = completeWorkflow[i];
-                const nextStatus = completeWorkflow[i + 1];
-                const result = isForwardProgression(currentStatus, nextStatus);
-                assert.strictEqual(result, true, `Workflow step ${i + 1}: Should allow progression from ${currentStatus} to ${nextStatus}`);
-            }
-            // Test that you can't go backwards at any point in the workflow
-            for (let i = 1; i < completeWorkflow.length; i++) {
-                const currentStatus = completeWorkflow[i];
-                const previousStatus = completeWorkflow[i - 1];
-                const result = isForwardProgression(currentStatus, previousStatus);
-                assert.strictEqual(result, false, `Workflow regression check ${i}: Should prevent regression from ${currentStatus} to ${previousStatus}`);
-            }
-        });
-    });
-    describe('Status Progression Order Validation', () => {
-        it('should ensure progression order matches business workflow', () => {
-            // Verify that the progression order makes business sense
-            const criticalStatusPositions = {
-                backlog: STATUS_PROGRESSION_ORDER.indexOf('backlog'),
-                ready_for_dev: STATUS_PROGRESSION_ORDER.indexOf('ready_for_dev'),
-                feature_analysis: STATUS_PROGRESSION_ORDER.indexOf('feature_analysis'),
-                technical_design: STATUS_PROGRESSION_ORDER.indexOf('technical_design'),
-                code_implementation: STATUS_PROGRESSION_ORDER.indexOf('code_implementation'),
-                functional_testing: STATUS_PROGRESSION_ORDER.indexOf('functional_testing'),
-                deployment: STATUS_PROGRESSION_ORDER.indexOf('deployment'),
-                shipped: STATUS_PROGRESSION_ORDER.indexOf('shipped'),
-            };
-            // Verify logical ordering
-            assert.ok(criticalStatusPositions.backlog < criticalStatusPositions.ready_for_dev, 'Backlog should come before ready_for_dev');
-            assert.ok(criticalStatusPositions.ready_for_dev < criticalStatusPositions.feature_analysis, 'Ready for dev should come before feature analysis');
-            assert.ok(criticalStatusPositions.feature_analysis < criticalStatusPositions.technical_design, 'Feature analysis should come before technical design');
-            assert.ok(criticalStatusPositions.technical_design < criticalStatusPositions.code_implementation, 'Technical design should come before code implementation');
-            assert.ok(criticalStatusPositions.code_implementation < criticalStatusPositions.functional_testing, 'Code implementation should come before functional testing');
-            assert.ok(criticalStatusPositions.functional_testing < criticalStatusPositions.deployment, 'Functional testing should come before deployment');
-            assert.ok(criticalStatusPositions.deployment < criticalStatusPositions.shipped, 'Deployment should come before shipped');
-        });
-        it('should prevent CLI from causing any backward movement', () => {
-            // This test specifically addresses the original issue:
-            // "After running CLI, in some phases, it update feature status to 'Backlog'"
-            // No matter what the current status is, CLI should NEVER be able to set it to backlog
-            for (const currentStatus of STATUS_PROGRESSION_ORDER.slice(1)) {
-                const result = isForwardProgression(currentStatus, 'backlog');
-                assert.strictEqual(result, false, `CLI should NEVER be able to regress ${currentStatus} to backlog`);
-            }
-        });
-    });
-});

package/dist/api/features/__tests__/status-updater.integration.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Integration tests for status updater functionality
- * Tests the complete flow including MCP calls and error handling
- */
-export {};