edsger 0.22.4 → 0.23.1

package/dist/commands/workflow/config/phase-configs.js

@@ -10,6 +10,7 @@ import { writeCodeTests } from '../../../phases/code-testing/analyzer.js';
 import { refineCodeFromPRFeedback } from '../../../phases/code-refine/index.js';
 import { verifyAndResolveComments } from '../../../phases/code-refine-verification/index.js';
 import { reviewPullRequest } from '../../../phases/code-review/index.js';
+import { runAutonomousDevelopment } from '../../../phases/autonomous/index.js';
 import { getGitHubConfig } from '../../../api/github.js';
 /**
  * Wrapper for code-refine phase to inject GitHub token
@@ -104,4 +105,8 @@ export const phaseConfigs = [
         name: 'code-review',
         execute: executeCodeReview,
     },
+    {
+        name: 'autonomous',
+        execute: runAutonomousDevelopment,
+    },
 ];

package/dist/commands/workflow/core/workflow-logger.d.ts

@@ -18,3 +18,6 @@ export declare const logAllFeaturesProcessed: () => void;
 export declare const logSkippingProcessing: (processingCount: number) => void;
 export declare const logPollingError: (error: unknown) => void;
 export declare const logProcessNextFeatureError: (error: unknown) => void;
+export declare const logAutonomousIterationStart: (iteration: number, remainingHours: number) => void;
+export declare const logAutonomousIterationComplete: (iteration: number, summary: string, prUrl?: string) => void;
+export declare const logAutonomousPhaseComplete: (totalIterations: number, elapsedHours: number) => void;

package/dist/commands/workflow/core/workflow-logger.js

@@ -63,3 +63,15 @@ export const logPollingError = (error) => {
 export const logProcessNextFeatureError = (error) => {
     logError(`Error in processNextFeature: ${error instanceof Error ? error.message : String(error)}`);
 };
+export const logAutonomousIterationStart = (iteration, remainingHours) => {
+    logInfo(`🔄 Autonomous iteration ${iteration} (${remainingHours.toFixed(1)}h remaining)`);
+};
+export const logAutonomousIterationComplete = (iteration, summary, prUrl) => {
+    logSuccess(`✅ Iteration ${iteration}: ${summary}`);
+    if (prUrl) {
+        logInfo(`   PR: ${prUrl}`);
+    }
+};
+export const logAutonomousPhaseComplete = (totalIterations, elapsedHours) => {
+    logSuccess(`🏁 Autonomous development completed: ${totalIterations} iterations in ${elapsedHours.toFixed(2)} hours`);
+};

package/dist/commands/workflow/executors/phase-executor.d.ts

@@ -4,5 +4,5 @@
 import { EdsgerConfig } from '../../../types/index.js';
 import { PipelinePhaseOptions, PipelineResult, PhaseConfig } from '../../../types/pipeline.js';
 export declare const createPhaseRunner: (phaseConfig: PhaseConfig) => (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
-declare const runFeatureAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTechnicalDesignPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runBranchPlanningPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeImplementationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runFunctionalTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefinePhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefineVerificationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeReviewPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
-export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, };
+declare const runFeatureAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTechnicalDesignPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runBranchPlanningPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeImplementationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runFunctionalTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefinePhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefineVerificationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeReviewPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runAutonomousPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
+export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase, };

package/dist/commands/workflow/executors/phase-executor.js

@@ -262,6 +262,6 @@ export const createPhaseRunner = (phaseConfig) => async (options, config) => {
     }
 };
 // Create phase runners using the configuration
-const [runFeatureAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase,] = phaseConfigs.map(createPhaseRunner);
+const [runFeatureAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase,] = phaseConfigs.map(createPhaseRunner);
 // Export individual phase runners for granular control
-export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, };
+export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase, };

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

@@ -13,7 +13,7 @@ import { getFeature } from '../../api/features/get-feature.js';
 import { markWorkflowPhaseCompleted } from '../../api/features/update-feature.js';
 import { logError, logInfo, logWarning } from '../../utils/logger.js';
 import { logPhaseResult } from '../../utils/pipeline-logger.js';
-import { runFeatureAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeRefinePhase, runCodeReviewPhase, } from './executors/phase-executor.js';
+import { runFeatureAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeRefinePhase, runCodeReviewPhase, runAutonomousPhase, } from './executors/phase-executor.js';
 /**
  * Map workflow phase names (underscore format) to phase runner functions
  * Note: code_refine includes built-in verification loop (similar to technical_design)
@@ -26,6 +26,7 @@ const PHASE_RUNNERS = {
     functional_testing: runFunctionalTestingPhase,
     code_review: runCodeReviewPhase,
     code_refine: runCodeRefinePhase,
+    autonomous: runAutonomousPhase,
 };
 /**
  * Get all pending phases from workflow in order

package/dist/phases/autonomous/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Autonomous Development Phase
+ *
+ * Runs a time-limited loop where Claude Code SDK analyzes the codebase,
+ * decides the next actionable step toward the feature's objective (description),
+ * implements it, and commits. All iterations build on the same branch.
+ * A PR is created after the first iteration; subsequent pushes update it.
+ */
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
+import { PipelinePhaseOptions } from '../../types/pipeline.js';
+export interface AutonomousResult {
+    featureId: string;
+    status: 'success' | 'error';
+    message: string;
+    branchName: string;
+    totalIterations: number;
+    elapsedHours: number;
+    prUrl?: string;
+}
+/**
+ * Main entry point for autonomous development phase
+ */
+export declare function runAutonomousDevelopment(options: PipelinePhaseOptions, config: EdsgerConfig, _checklistContext?: ChecklistPhaseContext | null): Promise<any>;

package/dist/phases/autonomous/index.js

@@ -0,0 +1,404 @@
+/**
+ * Autonomous Development Phase
+ *
+ * Runs a time-limited loop where Claude Code SDK analyzes the codebase,
+ * decides the next actionable step toward the feature's objective (description),
+ * implements it, and commits. All iterations build on the same branch.
+ * A PR is created after the first iteration; subsequent pushes update it.
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { logInfo, logError } from '../../utils/logger.js';
+import { getFeature } from '../../api/features/get-feature.js';
+import { createBranches, getCurrentBranch, updateBranch, } from '../../services/branches.js';
+import { prepareCustomBranchGitEnvironmentAsync, resetUncommittedChanges, } from '../../utils/git-branch-manager.js';
+import { createBranchPullRequest, } from '../code-implementation/branch-pr-creator.js';
+import { getGitHubConfig } from '../../api/github.js';
+import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
+import { createAutonomousSystemPrompt, createAutonomousUserPrompt, } from './prompts.js';
+/**
+ * Truncate text to a maximum length, adding ellipsis if truncated
+ */
+function truncateText(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    return text.slice(0, maxLength - 3) + '...';
+}
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: content },
+    };
+}
+async function* prompt(userPrompt) {
+    yield userMessage(userPrompt);
+    await new Promise((res) => setTimeout(res, 10000));
+}
+/**
+ * Push branch to remote repository
+ */
+async function pushToRemote(branchName, verbose) {
+    try {
+        const { execSync } = await import('child_process');
+        if (verbose) {
+            logInfo(`📤 Pushing branch ${branchName} to remote...`);
+        }
+        try {
+            execSync(`git push -u origin ${branchName}`, {
+                encoding: 'utf-8',
+                stdio: verbose ? 'inherit' : 'pipe',
+            });
+            return { success: true };
+        }
+        catch {
+            try {
+                execSync(`git push origin ${branchName}`, {
+                    encoding: 'utf-8',
+                    stdio: verbose ? 'inherit' : 'pipe',
+                });
+                return { success: true };
+            }
+            catch {
+                if (verbose) {
+                    logInfo(`⚠️  Push rejected, attempting force push with lease...`);
+                }
+                try {
+                    execSync(`git push --force-with-lease origin ${branchName}`, {
+                        encoding: 'utf-8',
+                        stdio: verbose ? 'inherit' : 'pipe',
+                    });
+                    return { success: true };
+                }
+                catch (forceError) {
+                    return {
+                        success: false,
+                        error: forceError instanceof Error
+                            ? forceError.message
+                            : String(forceError),
+                    };
+                }
+            }
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Run a single autonomous iteration using Claude Code SDK
+ */
+async function runIteration(featureId, featureDescription, config, verbose) {
+    const systemPrompt = createAutonomousSystemPrompt(config, featureId);
+    const userPromptText = createAutonomousUserPrompt(featureDescription);
+    let lastAssistantResponse = '';
+    for await (const message of query({
+        prompt: prompt(userPromptText),
+        options: {
+            systemPrompt: {
+                type: 'preset',
+                preset: 'claude_code',
+                append: systemPrompt,
+            },
+            model: DEFAULT_MODEL,
+            maxTurns: 3000,
+            permissionMode: 'bypassPermissions',
+        },
+    })) {
+        if (verbose) {
+            logInfo(`Received message type: ${message.type}`);
+        }
+        if (message.type === 'assistant' && message.message?.content) {
+            for (const content of message.message.content) {
+                if (content.type === 'text') {
+                    lastAssistantResponse += content.text + '\n';
+                    if (verbose) {
+                        console.log(`\n🤖 ${content.text}`);
+                    }
+                }
+                else if (content.type === 'tool_use') {
+                    if (verbose) {
+                        console.log(`\n🔧 ${content.name}: ${content.input.description || 'Running...'}`);
+                    }
+                }
+            }
+        }
+        if (message.type === 'result') {
+            if (message.subtype === 'success') {
+                try {
+                    const responseText = message.result || lastAssistantResponse;
+                    const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                    let jsonResult = null;
+                    if (jsonBlockMatch) {
+                        jsonResult = JSON.parse(jsonBlockMatch[1]);
+                    }
+                    else {
+                        jsonResult = JSON.parse(responseText);
+                    }
+                    if (jsonResult?.autonomous_result) {
+                        const result = jsonResult.autonomous_result;
+                        return {
+                            success: true,
+                            summary: result.summary,
+                            taskType: result.task_type,
+                            filesModified: result.files_modified,
+                            commitHash: result.commit_hash,
+                        };
+                    }
+                    // JSON parsed but missing autonomous_result key
+                    logInfo('⚠️  JSON result missing autonomous_result key, treating as success');
+                    return {
+                        success: true,
+                        summary: 'Autonomous iteration completed (missing result key)',
+                    };
+                }
+                catch {
+                    // JSON parsing failed - still consider it a success if Claude did work
+                    logInfo('⚠️  Could not parse structured result, treating as success');
+                    return {
+                        success: true,
+                        summary: 'Autonomous iteration completed (unstructured result)',
+                    };
+                }
+            }
+            else {
+                logError(`⚠️  Autonomous iteration incomplete: ${message.subtype}`);
+                return { success: false };
+            }
+        }
+    }
+    return { success: false };
+}
+/**
+ * Main entry point for autonomous development phase
+ */
+export async function runAutonomousDevelopment(options, config, _checklistContext) {
+    const { featureId, verbose } = options;
+    const startTime = Date.now();
+    logInfo(`\n🤖 Starting autonomous development for feature: ${featureId}`);
+    // 1. Fetch feature info to get description (= objective) and autonomous_hours
+    const feature = await getFeature(featureId, verbose);
+    const featureDescription = feature.description || '';
+    const autonomousHours = feature.autonomous_hours || 4;
+    if (!featureDescription) {
+        return {
+            featureId,
+            status: 'error',
+            message: 'Feature description is required for autonomous mode (it serves as the objective)',
+        };
+    }
+    const endTime = startTime + autonomousHours * 3600000;
+    logInfo(`⏰ Autonomous mode will run for ${autonomousHours} hour(s)`);
+    logInfo(`🎯 Objective: ${truncateText(featureDescription.replace(/<[^>]*>/g, ''), 200)}`);
+    // 2. Get or create branch
+    let currentBranch = null;
+    try {
+        currentBranch = await getCurrentBranch({ featureId, verbose });
+    }
+    catch {
+        if (verbose) {
+            logInfo('No existing branch found, will create one');
+        }
+    }
+    if (!currentBranch) {
+        const featureName = truncateText(feature.name || 'Autonomous Development', 100);
+        const defaultBranchName = `dev/${featureId}`;
+        const createdBranches = await createBranches({ featureId, verbose }, [
+            {
+                name: featureName,
+                description: `Autonomous development branch for: ${featureName}`,
+                branch_name: defaultBranchName,
+                status: 'pending',
+            },
+        ]);
+        if (createdBranches.length > 0) {
+            currentBranch = createdBranches[0];
+            if (verbose) {
+                logInfo(`✅ Created branch: ${currentBranch.branch_name}`);
+            }
+        }
+    }
+    if (!currentBranch) {
+        return {
+            featureId,
+            status: 'error',
+            message: 'Failed to create or find a branch for autonomous development',
+        };
+    }
+    const devBranchName = currentBranch.branch_name || `dev/${featureId}`;
+    // 3. Update branch status to in_progress
+    if (currentBranch.status === 'pending') {
+        try {
+            await updateBranch(currentBranch.id, { status: 'in_progress' }, verbose);
+        }
+        catch (error) {
+            if (verbose) {
+                logError(`Failed to update branch status: ${error}`);
+            }
+        }
+    }
+    // 4. Prepare git environment (checkout branch + rebase with main)
+    const { cleanup: cleanupGit } = await prepareCustomBranchGitEnvironmentAsync({
+        featureBranch: devBranchName,
+        baseBranch: 'main',
+        verbose,
+        resolveConflicts: true,
+        conflictResolverConfig: {
+            model: DEFAULT_MODEL,
+        },
+    });
+    let totalIterations = 0;
+    let prUrl;
+    let prNumber;
+    try {
+        // 5. Main autonomous loop
+        while (Date.now() < endTime) {
+            totalIterations++;
+            const iterationStart = Date.now();
+            logInfo(`\n${'='.repeat(60)}\n🔄 Autonomous iteration ${totalIterations}\n${'='.repeat(60)}`);
+            // Run iteration
+            const iterationResult = await runIteration(featureId, featureDescription, config, verbose);
+            const iterationDuration = Date.now() - iterationStart;
+            logInfo(`⏱️  Iteration ${totalIterations} took ${(iterationDuration / 1000).toFixed(0)}s`);
+            if (iterationResult.success) {
+                logInfo(`✅ Iteration ${totalIterations}: ${iterationResult.summary || 'completed'}`);
+                // Push to remote
+                const pushResult = await pushToRemote(devBranchName, verbose);
+                if (!pushResult.success && verbose) {
+                    logError(`⚠️  Failed to push: ${pushResult.error}`);
+                }
+                // Create PR after first successful iteration
+                if (!prUrl) {
+                    const githubConfig = await getGitHubConfig(featureId, verbose);
+                    if (githubConfig.configured &&
+                        githubConfig.token &&
+                        githubConfig.owner &&
+                        githubConfig.repo) {
+                        const prConfig = {
+                            githubToken: githubConfig.token,
+                            owner: githubConfig.owner,
+                            repo: githubConfig.repo,
+                            verbose,
+                        };
+                        logInfo(`📝 Creating pull request for autonomous work...`);
+                        const prResult = await createBranchPullRequest(prConfig, devBranchName, currentBranch.name, currentBranch.description ||
+                            'Autonomous development implementation', 'main');
+                        if (prResult.success) {
+                            prUrl = prResult.pullRequestUrl;
+                            prNumber = prResult.pullRequestNumber;
+                            logInfo(`✅ Pull request created: ${prUrl}`);
+                        }
+                        else if (verbose) {
+                            logError(`⚠️  Failed to create pull request: ${prResult.error}`);
+                        }
+                    }
+                    else if (verbose) {
+                        logInfo('⚠️  GitHub not configured, skipping PR creation');
+                    }
+                }
+                // Log iteration completion to audit logs
+                await logFeaturePhaseEvent({
+                    featureId,
+                    eventType: 'autonomous_iteration_completed',
+                    phase: 'autonomous',
+                    result: 'success',
+                    metadata: {
+                        iteration: totalIterations,
+                        task_type: iterationResult.taskType,
+                        summary: iterationResult.summary,
+                        files_modified: iterationResult.filesModified || [],
+                        commit_hash: iterationResult.commitHash || '',
+                        duration_ms: iterationDuration,
+                        pr_url: prUrl || null,
+                        elapsed_hours: ((Date.now() - startTime) / 3600000).toFixed(2),
+                        remaining_hours: ((endTime - Date.now()) / 3600000).toFixed(2),
+                        timestamp: new Date().toISOString(),
+                    },
+                }, verbose);
+            }
+            else {
+                logError(`❌ Iteration ${totalIterations} failed`);
+                // Reset any uncommitted changes before next iteration
+                try {
+                    resetUncommittedChanges(verbose);
+                }
+                catch {
+                    // Ignore cleanup errors
+                }
+                // Log iteration failure to audit logs
+                await logFeaturePhaseEvent({
+                    featureId,
+                    eventType: 'autonomous_iteration_failed',
+                    phase: 'autonomous',
+                    result: 'error',
+                    metadata: {
+                        iteration: totalIterations,
+                        duration_ms: iterationDuration,
+                        elapsed_hours: ((Date.now() - startTime) / 3600000).toFixed(2),
+                        remaining_hours: ((endTime - Date.now()) / 3600000).toFixed(2),
+                        timestamp: new Date().toISOString(),
+                    },
+                    errorMessage: 'Autonomous iteration failed',
+                }, verbose);
+            }
+            // Check time before starting next iteration
+            if (Date.now() >= endTime) {
+                logInfo(`\n⏰ Time limit reached after ${totalIterations} iterations`);
+                break;
+            }
+        }
+        // 6. Update branch status to ready_for_review
+        try {
+            await updateBranch(currentBranch.id, {
+                status: 'ready_for_review',
+                pull_request_url: prUrl || null,
+                pull_request_number: prNumber || null,
+            }, verbose);
+            if (verbose) {
+                logInfo(`✅ Updated branch status to ready_for_review`);
+            }
+        }
+        catch (error) {
+            if (verbose) {
+                logError(`Failed to update branch status: ${error}`);
+            }
+        }
+        const elapsedHours = (Date.now() - startTime) / 3600000;
+        logInfo(`\n${'='.repeat(60)}`);
+        logInfo(`🏁 Autonomous development completed`);
+        logInfo(`   Total iterations: ${totalIterations}`);
+        logInfo(`   Elapsed time: ${elapsedHours.toFixed(2)} hours`);
+        logInfo(`   Branch: ${devBranchName}`);
+        if (prUrl) {
+            logInfo(`   PR: ${prUrl}`);
+        }
+        logInfo(`${'='.repeat(60)}\n`);
+        return {
+            featureId,
+            status: 'success',
+            message: `Autonomous development completed: ${totalIterations} iterations in ${elapsedHours.toFixed(2)} hours`,
+            branchName: devBranchName,
+            totalIterations,
+            elapsedHours,
+            prUrl,
+        };
+    }
+    catch (error) {
+        const elapsedHours = (Date.now() - startTime) / 3600000;
+        logError(`Autonomous development failed: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            featureId,
+            status: 'error',
+            message: `Autonomous development failed: ${error instanceof Error ? error.message : String(error)}`,
+            branchName: devBranchName,
+            totalIterations,
+            elapsedHours,
+        };
+    }
+    finally {
+        cleanupGit();
+    }
+}

package/dist/phases/autonomous/prompts.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Prompts for the autonomous development phase
+ */
+import { EdsgerConfig } from '../../types/index.js';
+export declare function createAutonomousSystemPrompt(_config: EdsgerConfig, featureId: string): string;
+export declare function createAutonomousUserPrompt(featureDescription: string): string;

package/dist/phases/autonomous/prompts.js

@@ -0,0 +1,74 @@
+/**
+ * Prompts for the autonomous development phase
+ */
+export function createAutonomousSystemPrompt(_config, featureId) {
+    return `You are an autonomous developer working toward a specific objective. Your role is to analyze the current state of the codebase, decide the next most valuable step toward the objective, implement it, and commit your changes.
+
+**Your Role**: Analyze the codebase, identify the next actionable improvement, implement it, and commit.
+
+**Available Tools**:
+- Bash: Git operations, running commands, tests, and builds
+- Glob: Find files and understand project structure
+- Read: Examine existing code, configuration, and documentation files
+- Edit: Modify existing files
+- Write: Create new files
+- TodoWrite: Track implementation tasks
+
+**WORKFLOW - Follow these steps**:
+
+1. **ANALYZE**: Use Glob and Read to understand the current state of the code
+2. **DECIDE**: Based on the objective, determine the single most impactful next step
+3. **IMPLEMENT**: Make the changes using Edit/Write tools
+4. **TEST**: Run relevant tests or builds to verify your changes work
+5. **COMMIT**: Commit your changes with a conventional commit message (feat:, fix:, refactor:, docs:, test:, chore:)
+
+**Types of work you may do**:
+- Implement new feature code toward the objective
+- Fix bugs discovered during analysis
+- Refactor code to improve quality or maintainability
+- Add or improve tests
+- Update documentation
+- Improve error handling or validation
+
+**Important Rules**:
+1. You are already on the correct branch - do NOT create or switch branches
+2. Focus on ONE coherent change per iteration
+3. Use conventional commit messages that describe what and why
+4. Follow existing code patterns and conventions in the repository
+5. Ensure proper TypeScript types and interfaces
+6. Add appropriate error handling and validation
+7. Handle pre-commit hooks properly:
+   - If lint-staged fails: Fix formatting and linting issues, then retry commit
+   - If AI code review fails: Use SKIP_REVIEW=1 git commit -m "message"
+   - Last resort: git commit --no-verify -m "message"
+
+**CRITICAL - Result Format**:
+You MUST end your response with a JSON object in this EXACT format:
+
+\`\`\`json
+{
+  "autonomous_result": {
+    "feature_id": "${featureId}",
+    "task_type": "feature|bugfix|refactor|test|docs|chore",
+    "summary": "Brief description of what was done",
+    "files_modified": ["file1.ts", "file2.tsx"],
+    "commit_hash": "abc123..."
+  }
+}
+\`\`\`
+
+Remember: Focus on making real, meaningful progress toward the objective. Quality over quantity.`;
+}
+export function createAutonomousUserPrompt(featureDescription) {
+    return `## Objective
+
+${featureDescription}
+
+## Instructions
+
+Analyze the current state of the codebase. Based on the objective above, decide the next most valuable step to move toward the goal. Implement the change, verify it works, and commit it.
+
+Focus on ONE coherent, well-scoped change. Make real progress toward the objective.
+
+Begin by analyzing the codebase to understand the current state and decide your next step.`;
+}

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

@@ -5,14 +5,11 @@ import { executeAnalysisQuery } from './agent.js';
 import { performVerificationCycle } from '../feature-analysis-verification/index.js';
 import { deleteArtifacts, deleteSpecificArtifacts, updateArtifactsToReady, saveAnalysisArtifactsAsDraft, buildAnalysisResult, } from './outcome.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
-import { preparePhaseGitEnvironment } from '../../utils/git-branch-manager.js';
 export const analyseFeature = async (options, config, checklistContext) => {
     const { featureId, verbose } = options;
     if (verbose) {
         logInfo(`Starting feature analysis for feature ID: ${featureId}`);
     }
-    // Prepare git environment: switch to feature branch and rebase with main
-    const cleanupGit = preparePhaseGitEnvironment(featureId, 'main', verbose);
     try {
         const context = await prepareAnalysisContext(featureId, checklistContext, verbose);
         const systemPrompt = createFeatureAnalysisSystemPrompt();
@@ -157,8 +154,4 @@ export const analyseFeature = async (options, config, checklistContext) => {
             status: 'error',
         };
     }
-    finally {
-        // Always return to main branch after phase completion
-        cleanupGit();
-    }
 };

package/dist/services/audit-logs.d.ts

@@ -4,8 +4,8 @@
  */
 export interface LogPhaseEventParams {
     featureId: string;
-    eventType: 'phase_started' | 'phase_completed' | 'phase_failed';
-    phase: 'feature_analysis' | 'technical_design' | 'branch_planning' | 'code_implementation' | 'functional_testing' | 'pull_request' | 'code_review' | 'code_refine' | 'code_refine_verification';
+    eventType: 'phase_started' | 'phase_completed' | 'phase_failed' | 'autonomous_iteration_completed' | 'autonomous_iteration_failed';
+    phase: 'feature_analysis' | 'technical_design' | 'branch_planning' | 'code_implementation' | 'functional_testing' | 'pull_request' | 'code_review' | 'code_refine' | 'code_refine_verification' | 'autonomous';
     result?: 'success' | 'error' | 'warning' | 'info';
     metadata?: Record<string, any>;
     errorMessage?: string;

package/dist/types/features.d.ts

@@ -8,6 +8,7 @@ export interface FeatureInfo {
     product_id: string;
     execution_mode?: string;
     workflow?: FeatureWorkflow | null;
+    autonomous_hours?: number;
     created_at?: string;
     updated_at?: string;
 }

package/dist/types/pipeline.d.ts

@@ -3,7 +3,7 @@
  */
 import { EdsgerConfig } from './index.js';
 import { ChecklistPhaseContext } from '../services/checklist.js';
-export type ExecutionMode = 'full_pipeline' | 'only_feature_analysis' | 'only_technical_design' | 'only_branch_planning' | 'only_code_implementation' | 'only_functional_testing' | 'only_code_refine' | 'only_code_review' | 'from_feature_analysis' | 'from_technical_design' | 'from_branch_planning' | 'from_code_implementation' | 'from_functional_testing' | 'from_code_review' | 'custom';
+export type ExecutionMode = 'full_pipeline' | 'only_feature_analysis' | 'only_technical_design' | 'only_branch_planning' | 'only_code_implementation' | 'only_functional_testing' | 'only_code_refine' | 'only_code_review' | 'from_feature_analysis' | 'from_technical_design' | 'from_branch_planning' | 'from_code_implementation' | 'from_functional_testing' | 'from_code_review' | 'custom' | 'autonomous';
 export type WorkflowPhaseStatus = 'pending' | 'completed';
 export interface WorkflowPhase {
     phase: string;

package/package.json

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