edsger 0.77.0 → 0.78.0

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

@@ -1,153 +0,0 @@
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-const PLAN_OPEN = '<<<EXECUTION_PLAN>>>';
-const PLAN_CLOSE = '<<<END_EXECUTION_PLAN>>>';
-/** Extract the markdown plan delimited by sentinel markers, if present. */
-function extractPlanBetweenSentinels(responseText) {
-    const start = responseText.indexOf(PLAN_OPEN);
-    if (start === -1) {
-        return null;
-    }
-    const end = responseText.indexOf(PLAN_CLOSE, start + PLAN_OPEN.length);
-    if (end === -1) {
-        return null;
-    }
-    return responseText.slice(start + PLAN_OPEN.length, end).trim();
-}
-/** Extract the metadata JSON object from a fenced \`\`\`json block, or fall back
- * to parsing the entire text as JSON. Returns the inner `analysis` object if
- * the JSON has the expected shape. */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function extractMetadataJson(responseText) {
-    const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-    const candidates = [];
-    if (jsonBlockMatch) {
-        candidates.push(jsonBlockMatch[1]);
-    }
-    candidates.push(responseText);
-    for (const candidate of candidates) {
-        try {
-            const parsed = JSON.parse(candidate);
-            if (parsed && parsed.analysis) {
-                return parsed.analysis;
-            }
-        }
-        catch {
-            // try the next candidate
-        }
-    }
-    return null;
-}
-/**
- * Parse the structured analysis response.
- *
- * Two acceptable forms:
- *   1. Sentinel-delimited markdown plan + a separate JSON metadata block (preferred).
- *   2. A single JSON object whose `analysis.execution_plan` field carries
- *      the full plan as an escaped string (legacy / fallback).
- *
- * The first form is robust to unescaped quotes/newlines in the markdown,
- * which models frequently get wrong when the plan is large.
- */
-export function parseAnalysisResult(responseText) {
-    const plan = extractPlanBetweenSentinels(responseText);
-    const metadata = extractMetadataJson(responseText);
-    if (plan !== null) {
-        // Sentinel form. Metadata is optional — if it's missing or malformed,
-        // we still surface the plan so the workflow can persist it.
-        return {
-            analysis: {
-                ...(metadata ?? {}),
-                execution_plan: plan,
-            },
-        };
-    }
-    if (metadata !== null) {
-        // Legacy form: plan embedded in JSON.
-        return { analysis: metadata };
-    }
-    return {
-        error: 'Could not extract execution plan: missing both sentinel markers and a parseable JSON metadata block',
-    };
-}
-function userMessage(content) {
-    return {
-        type: 'user',
-        message: { role: 'user', content },
-    };
-}
-// eslint-disable-next-line @typescript-eslint/require-await -- async generator required by SDK interface
-async function* prompt(analysisPrompt) {
-    yield userMessage(analysisPrompt);
-}
-export async function executeAnalysisQuery(currentPrompt, systemPrompt, config, verbose) {
-    let lastAssistantResponse = '';
-    let structuredAnalysisResult = null;
-    let executionSessionId = '';
-    for await (const message of query({
-        prompt: prompt(currentPrompt),
-        options: {
-            systemPrompt: {
-                type: 'preset',
-                preset: 'claude_code',
-                append: systemPrompt,
-            },
-            model: DEFAULT_MODEL,
-            maxTurns: 1000,
-            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`;
-                    logDebug(`🤖 ${content.text}`, verbose);
-                }
-                else if (content.type === 'tool_use') {
-                    const input = (content.input ?? {});
-                    logDebug(`🔧 ${content.name}: ${input.description ?? 'Running...'}`, verbose);
-                }
-            }
-        }
-        if (message.type === 'result') {
-            executionSessionId = message.session_id || executionSessionId;
-            if (message.subtype === 'success') {
-                logInfo('\n📊 Issue analysis completed, parsing execution plan...');
-                const responseText = message.result || lastAssistantResponse;
-                const parsed = parseAnalysisResult(responseText);
-                if (parsed.error) {
-                    logError(`Failed to parse structured analysis result: ${parsed.error}`);
-                    structuredAnalysisResult = {
-                        status: 'error',
-                        summary: `Failed to parse execution plan: ${parsed.error}`,
-                        execution_plan: '',
-                    };
-                }
-                else {
-                    structuredAnalysisResult = parsed.analysis;
-                }
-            }
-            else {
-                logError(`\n⚠️ Analysis incomplete: ${message.subtype}`);
-                if (message.subtype === 'error_max_turns') {
-                    logError('💡 Try increasing timeout or reducing complexity');
-                }
-                if (lastAssistantResponse) {
-                    const parsed = parseAnalysisResult(lastAssistantResponse);
-                    if (!parsed.error) {
-                        structuredAnalysisResult = parsed.analysis;
-                    }
-                }
-            }
-        }
-    }
-    if (structuredAnalysisResult) {
-        structuredAnalysisResult.execution_session_id =
-            executionSessionId || undefined;
-    }
-    return structuredAnalysisResult;
-}

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

@@ -1,20 +0,0 @@
-import { type ProductInfo } from '../../api/products.js';
-import { type ChecklistPhaseContext } from '../../services/checklist.js';
-import type { IssueInfo } from '../../types/issues.js';
-export interface IssueAnalysisContext {
-    issue: IssueInfo;
-    product: ProductInfo;
-}
-/**
- * Fetch issue + product context. The plan-generation phase does not need
- * existing user stories or test cases — those are downstream artifacts that
- * the plan itself decides whether to produce.
- */
-export declare function fetchIssueAnalysisContext(issueId: string, verbose?: boolean): Promise<IssueAnalysisContext>;
-/**
- * Prepare context information needed for plan generation
- */
-export declare function prepareAnalysisContext(issueId: string, checklistContext: ChecklistPhaseContext | null | undefined, verbose?: boolean): Promise<{
-    issueContext: IssueAnalysisContext;
-    analysisPrompt: string;
-}>;

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

@@ -1,93 +0,0 @@
-import { getIssue } from '../../api/issues/index.js';
-import { getProduct } from '../../api/products.js';
-import { formatChecklistsForContext, } from '../../services/checklist.js';
-import { formatFeedbacksForContext, getFeedbacksForPhase, } from '../../services/feedbacks.js';
-import { formatIssueAnalysisContext } from '../../utils/formatters.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { createIssueAnalysisPromptWithContext } from './prompts.js';
-/**
- * Fetch issue + product context. The plan-generation phase does not need
- * existing user stories or test cases — those are downstream artifacts that
- * the plan itself decides whether to produce.
- */
-export async function fetchIssueAnalysisContext(issueId, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Fetching issue analysis context for issue: ${issueId}`);
-        }
-        const issue = await getIssue(issueId, verbose);
-        const product = await getProduct(issue.product_id, verbose);
-        if (verbose) {
-            logInfo(`✅ Issue analysis context fetched:`);
-            logInfo(`   Issue: ${issue.name}`);
-            logInfo(`   Product: ${product.name}`);
-        }
-        return { issue, product };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to fetch issue analysis context: ${errorMessage}`);
-        throw new Error(`Context fetch failed: ${errorMessage}`);
-    }
-}
-/**
- * Prepare context information needed for plan generation
- */
-export async function prepareAnalysisContext(issueId, checklistContext, verbose) {
-    if (verbose) {
-        logInfo('Fetching issue analysis context via MCP endpoints...');
-    }
-    const issueContext = await fetchIssueAnalysisContext(issueId, verbose);
-    const { content: contextInfo, downloadedImages } = await formatIssueAnalysisContext(issueContext);
-    if (verbose && downloadedImages.length > 0) {
-        logInfo(`Downloaded ${downloadedImages.length} images for Claude Code:`);
-        downloadedImages.forEach((img) => {
-            logInfo(`  - ${img.url} -> ${img.localPath}`);
-        });
-    }
-    let finalContextInfo = contextInfo;
-    // Add feedbacks context to the analysis prompt.
-    //
-    // The issue_analysis phase used to generate user_stories and test_cases.
-    // Pre-existing feedbacks tagged at line/range level against those documents
-    // (document_type in 'user_story' / 'test_case' / 'technical_design') are no
-    // longer relevant — the new phase only produces an execution plan. Drop
-    // them at the application layer so the model isn't asked to act on stale
-    // guidance. Phase-level feedbacks (document_type = null) and feedbacks
-    // explicitly targeting 'execution_plan' are kept.
-    try {
-        const feedbacksContext = await getFeedbacksForPhase({ issueId, verbose }, 'issue-analysis');
-        const relevantFeedbacks = feedbacksContext.feedbacks.filter((f) => !f.document_type || f.document_type === 'execution_plan');
-        const droppedCount = feedbacksContext.feedbacks.length - relevantFeedbacks.length;
-        if (relevantFeedbacks.length > 0) {
-            const feedbacksInfo = await formatFeedbacksForContext({
-                ...feedbacksContext,
-                feedbacks: relevantFeedbacks,
-            });
-            finalContextInfo = `${finalContextInfo}\n\n${feedbacksInfo}`;
-            if (verbose) {
-                logInfo(`Added ${relevantFeedbacks.length} human feedbacks to context${droppedCount > 0
-                    ? ` (dropped ${droppedCount} legacy feedbacks targeting user_story/test_case/technical_design — those are downstream artifacts, not plan inputs)`
-                    : ''}`);
-            }
-        }
-        else if (droppedCount > 0 && verbose) {
-            logInfo(`Skipped ${droppedCount} legacy feedbacks targeting user_story/test_case/technical_design`);
-        }
-    }
-    catch (error) {
-        if (verbose) {
-            logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
-        }
-    }
-    // Add checklist context to the analysis prompt
-    if (checklistContext && checklistContext.checklists.length > 0) {
-        const checklistInfo = formatChecklistsForContext(checklistContext);
-        finalContextInfo = `${finalContextInfo}\n\n${checklistInfo}`;
-        if (verbose) {
-            logInfo(`Added ${checklistContext.checklists.length} checklists to analysis context`);
-        }
-    }
-    const analysisPrompt = createIssueAnalysisPromptWithContext(issueId, finalContextInfo);
-    return { issueContext, analysisPrompt };
-}

package/dist/phases/issue-analysis/index.d.ts

@@ -1,8 +0,0 @@
-import { type ChecklistPhaseContext } from '../../services/checklist.js';
-import { type EdsgerConfig, type IssueAnalysisResult } from '../../types/index.js';
-export interface IssueAnalysisOptions {
-    issueId: string;
-    verbose?: boolean;
-    maxVerificationIterations?: number;
-}
-export declare const analyseIssue: (options: IssueAnalysisOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<IssueAnalysisResult>;

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

@@ -1,147 +0,0 @@
-import { logIssuePhaseEvent } from '../../services/audit-logs.js';
-import { extractChecklistItems, runPhaseCoaching, } from '../../services/coaching/index.js';
-import { logError, logInfo, logWarning } from '../../utils/logger.js';
-import { performVerificationCycle } from '../issue-analysis-verification/index.js';
-import { executeAnalysisQuery, parseAnalysisResult } from './agent.js';
-import { prepareAnalysisContext } from './context.js';
-import { buildAnalysisResult, saveExecutionPlan } from './outcome.js';
-import { createIssueAnalysisSystemPrompt } from './prompts.js';
-const buildErrorResult = (issueId, message) => ({
-    issueId,
-    productInfo: null,
-    issueInfo: null,
-    executionPlan: '',
-    summary: message,
-    status: 'error',
-});
-export const analyseIssue = async (options, config, checklistContext) => {
-    const { issueId, verbose } = options;
-    if (verbose) {
-        logInfo(`Starting issue analysis for issue ID: ${issueId}`);
-    }
-    try {
-        const context = await prepareAnalysisContext(issueId, checklistContext, verbose);
-        const systemPrompt = await createIssueAnalysisSystemPrompt();
-        const initialAnalysisPrompt = context.analysisPrompt;
-        const maxIterations = options.maxVerificationIterations || 10;
-        let currentIteration = 0;
-        let currentPrompt = initialAnalysisPrompt;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let structuredAnalysisResult = null;
-        let verificationResult = null;
-        if (verbose) {
-            logInfo('Starting Claude Code query with pre-fetched information...');
-        }
-        while (currentIteration < maxIterations) {
-            currentIteration++;
-            if (verbose && currentIteration > 1) {
-                logInfo(`\n🔄 Iteration ${currentIteration}/${maxIterations}: Revising plan based on verification feedback...`);
-            }
-            if (currentIteration > 1) {
-                await logIssuePhaseEvent({
-                    issueId,
-                    eventType: 'phase_started',
-                    phase: 'issue_analysis',
-                    result: 'info',
-                    metadata: {
-                        iteration: currentIteration,
-                        max_iterations: maxIterations,
-                        re_analysis: true,
-                        timestamp: new Date().toISOString(),
-                    },
-                }, verbose);
-            }
-            structuredAnalysisResult = await executeAnalysisQuery(currentPrompt, systemPrompt, config, verbose);
-            if (!structuredAnalysisResult) {
-                break;
-            }
-            const planLength = typeof structuredAnalysisResult.execution_plan === 'string'
-                ? structuredAnalysisResult.execution_plan.length
-                : 0;
-            await logIssuePhaseEvent({
-                issueId,
-                eventType: 'phase_completed',
-                phase: 'issue_analysis',
-                result: 'success',
-                metadata: {
-                    iteration: currentIteration,
-                    max_iterations: maxIterations,
-                    analysis_step: 'completed',
-                    execution_plan_length: planLength,
-                    timestamp: new Date().toISOString(),
-                },
-            }, verbose);
-            // Coaching loop between execute and verify — gives the agent a chance to
-            // refine its plan against checklist items before formal verification.
-            await runPhaseCoaching({
-                issueId,
-                phase: 'issue_analysis',
-                phaseResult: structuredAnalysisResult,
-                checklistItems: extractChecklistItems(checklistContext),
-                onImproved: async (_sessionId, responseText) => {
-                    const parsed = parseAnalysisResult(responseText);
-                    if (parsed.analysis) {
-                        structuredAnalysisResult = parsed.analysis;
-                    }
-                    else {
-                        logWarning(`Coaching improvement response could not be parsed for issue-analysis. Keeping previous plan. ${parsed.error || ''}`);
-                    }
-                },
-                verbose,
-            });
-            const verificationCycle = await performVerificationCycle({
-                structuredAnalysisResult,
-                checklistContext: checklistContext || null,
-                context: context.issueContext,
-                config,
-                currentIteration,
-                maxIterations,
-                issueId,
-                verbose,
-            });
-            ({ verificationResult } = verificationCycle);
-            if (verificationCycle.passed) {
-                if (verbose) {
-                    logInfo('✅ Plan verification passed.');
-                }
-                break;
-            }
-            if (currentIteration < maxIterations && verificationCycle.nextPrompt) {
-                currentPrompt = verificationCycle.nextPrompt;
-            }
-            else {
-                if (verbose) {
-                    logInfo('⚠️  Max iterations reached. Latest plan kept for manual review.');
-                }
-                break;
-            }
-        }
-        if (!structuredAnalysisResult) {
-            throw new Error('No analysis results received');
-        }
-        const executionPlan = typeof structuredAnalysisResult.execution_plan === 'string'
-            ? structuredAnalysisResult.execution_plan
-            : '';
-        if (executionPlan.trim().length > 0) {
-            const saved = await saveExecutionPlan(issueId, executionPlan, verbose);
-            if (!saved) {
-                logError('Failed to persist execution plan to issue');
-            }
-        }
-        else {
-            logError('Generated execution plan is empty; nothing persisted');
-        }
-        if (verificationResult &&
-            verificationResult.rejected_count > 0 &&
-            checklistContext &&
-            checklistContext.checklists.length > 0) {
-            logError(`❌ Final result: Plan verification FAILED after ${currentIteration} iterations`);
-            throw new Error(`Plan verification failed after ${currentIteration} iterations`);
-        }
-        return buildAnalysisResult(issueId, context.issueContext, structuredAnalysisResult, currentIteration);
-    }
-    catch (error) {
-        logError(`Issue analysis failed: ${error instanceof Error ? error.message : String(error)}`);
-        return buildErrorResult(issueId, `Analysis failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-};

package/dist/phases/issue-analysis/outcome.d.ts

@@ -1,10 +0,0 @@
-import { type IssueAnalysisResult } from '../../types/index.js';
-import { type IssueAnalysisContext } from './context.js';
-/**
- * Persist the generated execution plan onto the issue.
- */
-export declare function saveExecutionPlan(issueId: string, executionPlan: string, verbose?: boolean): Promise<boolean>;
-/**
- * Build the final analysis result object returned to the workflow runner.
- */
-export declare function buildAnalysisResult(issueId: string, context: IssueAnalysisContext, structuredAnalysisResult: any, currentIteration: number): IssueAnalysisResult;

package/dist/phases/issue-analysis/outcome.js

@@ -1,42 +0,0 @@
-import { updateExecutionPlan } from '../../api/issues/update-issue.js';
-import { logError, logInfo } from '../../utils/logger.js';
-/**
- * Persist the generated execution plan onto the issue.
- */
-export async function saveExecutionPlan(issueId, executionPlan, verbose) {
-    if (!executionPlan || executionPlan.trim().length === 0) {
-        logError('Refusing to save empty execution plan');
-        return false;
-    }
-    if (verbose) {
-        logInfo(`Saving execution plan (${executionPlan.length} chars) to issue ${issueId}...`);
-    }
-    const ok = await updateExecutionPlan(issueId, executionPlan, verbose);
-    if (verbose && ok) {
-        logInfo('✅ Execution plan saved');
-    }
-    return ok;
-}
-/**
- * Build the final analysis result object returned to the workflow runner.
- */
-export function buildAnalysisResult(issueId, context, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-structuredAnalysisResult, currentIteration) {
-    const { execution_plan, checklist_results, checklist_item_results } = structuredAnalysisResult;
-    return {
-        issueId,
-        productInfo: context.product,
-        issueInfo: context.issue,
-        executionPlan: typeof execution_plan === 'string' ? execution_plan : '',
-        summary: structuredAnalysisResult.summary ||
-            `Plan generated${currentIteration > 1 ? ` after ${currentIteration} iterations` : ''}`,
-        status: structuredAnalysisResult.status === 'success' ? 'success' : 'error',
-        data: {
-            checklist_results,
-            checklist_item_results,
-            verification_result: structuredAnalysisResult.verification_result,
-            iterations: currentIteration,
-        },
-    };
-}

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

@@ -1,8 +0,0 @@
-import { type ChecklistVerificationResult } from '../issue-analysis-verification/agent.js';
-export declare const createIssueAnalysisSystemPrompt: (projectDir?: string) => Promise<string>;
-export declare const createIssueAnalysisPromptWithContext: (issueId: string, contextInfo: string) => string;
-/**
- * Build a re-analysis prompt that asks the agent to revise its execution plan
- * based on verification feedback from issue-analysis-verification.
- */
-export declare const createImprovementPrompt: (verificationResult: ChecklistVerificationResult, previousPlan: string) => string;

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

@@ -1,99 +0,0 @@
-import { resolveSkill } from '../../services/skill-resolver.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-export const createIssueAnalysisSystemPrompt = async (projectDir) => {
-    const skill = await resolveSkill('phase/issue-analysis', { projectDir });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/issue-analysis');
-    }
-    return `${skill.prompt}\n\n${OUTPUT_CONTRACTS['issue-analysis']}`;
-};
-export const createIssueAnalysisPromptWithContext = (issueId, contextInfo) => {
-    return `Produce an execution plan for issue ID: ${issueId}
-
-${contextInfo}
-
-## Your task
-
-Read the issue and product context above and write a focused **execution plan** in markdown that captures:
-
-1. The kind of work this issue actually is (bug, feature, refactor, infra, spike, docs, or hybrid)
-2. Which artifacts the issue needs (user stories, test cases, technical design, branch plan, code implementation, functional testing, code review) — only the ones that genuinely add value for this kind of work
-3. The order to produce them, with dependencies noted
-4. Concrete, issue-specific success criteria for each artifact (NOT generic boilerplate)
-5. Risks / open questions a human should resolve
-
-Skip artifacts that don't apply with a one-line justification — don't pad. A trivial bug fix often needs only test cases + code implementation + code review.
-
-Return your plan via the JSON output contract: the markdown plan goes in the \`execution_plan\` field as a single string.
-
-Do not generate user stories or test cases inline. Do not write code. Do not run shell commands or use file-modifying tools.`;
-};
-/**
- * Build a re-analysis prompt that asks the agent to revise its execution plan
- * based on verification feedback from issue-analysis-verification.
- */
-export const createImprovementPrompt = (verificationResult, previousPlan) => {
-    const rejectedItemsSection = verificationResult.item_verifications
-        .filter((v) => v.verification_status === 'rejected')
-        .map((v, index) => {
-        return `### Rejected Requirement ${index + 1}
-**Checklist Item ID**: ${v.checklist_item_id}
-**Verification Result**: REJECTED
-**Reason**: ${v.verification_reason}
-${v.concerns && v.concerns.length > 0 ? `**Specific Concerns**:\n${v.concerns.map((c) => `- ${c}`).join('\n')}` : ''}
-${v.improvement_suggestions && v.improvement_suggestions.length > 0 ? `\n**Improvement Suggestions**:\n${v.improvement_suggestions.map((s) => `- ${s}`).join('\n')}` : ''}
-`;
-    })
-        .join('\n---\n');
-    const uncertainItemsSection = verificationResult.item_verifications
-        .filter((v) => v.verification_status === 'uncertain')
-        .map((v, index) => {
-        return `### Uncertain Requirement ${index + 1}
-**Checklist Item ID**: ${v.checklist_item_id}
-**Verification Result**: UNCERTAIN
-**Reason**: ${v.verification_reason}
-${v.concerns && v.concerns.length > 0 ? `**Specific Concerns**:\n${v.concerns.map((c) => `- ${c}`).join('\n')}` : ''}
-${v.improvement_suggestions && v.improvement_suggestions.length > 0 ? `\n**Improvement Suggestions**:\n${v.improvement_suggestions.map((s) => `- ${s}`).join('\n')}` : ''}
-`;
-    })
-        .join('\n---\n');
-    return `# Plan Verification Feedback - Revisions Required
-
-The execution plan you produced was reviewed and **${verificationResult.rejected_count} requirements were NOT SATISFIED** and **${verificationResult.uncertain_count} requirements are PARTIALLY SATISFIED**.
-
-## Verification Summary
-${verificationResult.summary}
-
-## Results Breakdown
-- Satisfied: ${verificationResult.confirmed_count}
-- Not Satisfied: ${verificationResult.rejected_count}
-- Partially Satisfied: ${verificationResult.uncertain_count}
-
-${verificationResult.overall_suggestions && verificationResult.overall_suggestions.length > 0 ? `## Overall Improvement Suggestions\n\n${verificationResult.overall_suggestions.map((s) => `- ${s}`).join('\n')}\n\n` : ''}
-
-${verificationResult.rejected_count > 0 ? `## Unsatisfied Requirements\n\n${rejectedItemsSection}` : ''}
-
-${verificationResult.uncertain_count > 0 ? `## Partially Satisfied Requirements\n\n${uncertainItemsSection}` : ''}
-
-## Your Previous Plan
-
-\`\`\`markdown
-${previousPlan}
-\`\`\`
-
----
-
-## Your Task: Revise the Plan
-
-Apply the verification suggestions above and return a **revised execution plan** that addresses every rejected/uncertain item. Keep the parts of your previous plan that were good. Common revisions:
-
-- Replace a generic success criterion with one that's specific to this issue
-- Reclassify the issue type if mismatched
-- Add or remove artifacts based on the specific feedback
-- Add a missing risk or open question
-- Reorder artifacts if dependencies are wrong
-
-Return the full revised plan via the JSON output contract — the markdown plan goes in the \`execution_plan\` field. Do NOT include explanatory text outside the JSON.
-
-MANDATORY: Include checklist_item_results for ALL checklist items in your response.`;
-};

package/dist/phases/issue-analysis-verification/agent.d.ts

@@ -1,33 +0,0 @@
-import { type ChecklistPhaseContext } from '../../services/checklist.js';
-import { type EdsgerConfig } from '../../types/index.js';
-import { type IssueAnalysisContext } from '../issue-analysis/context.js';
-export interface ChecklistItemVerificationResult {
-    checklist_item_id: string;
-    is_satisfied: boolean;
-    verification_status: 'confirmed' | 'rejected' | 'uncertain';
-    verification_reason: string;
-    concerns?: string[];
-    improvement_suggestions?: string[];
-}
-export interface ChecklistVerificationResult {
-    all_verified: boolean;
-    total_items: number;
-    confirmed_count: number;
-    rejected_count: number;
-    uncertain_count: number;
-    item_verifications: ChecklistItemVerificationResult[];
-    summary: string;
-    overall_suggestions?: string[];
-}
-export interface VerifyChecklistOptions {
-    checklistContext: ChecklistPhaseContext;
-    analysisContext: IssueAnalysisContext;
-    executionPlan: string;
-    verbose?: boolean;
-}
-/**
- * Verify execution plan quality against checklist requirements using an
- * independent AI agent. The agent reviews the plan markdown produced by
- * issue-analysis and decides whether each checklist item is satisfied.
- */
-export declare function verifyChecklistCompliance(options: VerifyChecklistOptions, _config: EdsgerConfig): Promise<ChecklistVerificationResult>;