elenchus_apply_fix

Instructions

Implementation Reference

• src/tools/issue-management.ts:78-166 (handler)

  The main handler function for 'elenchus_apply_fix'. Gets the session, finds the issue, creates a checkpoint before applying the fix, updates the issue status (RAISED if re-verify needed, RESOLVED otherwise), adds a transition record, refreshes file context by re-reading modified files, runs pre-analysis on modified files, and returns status/nextAction.

  export async function applyFix(
    args: z.infer<typeof ApplyFixSchema>
  ): Promise<{
    success: boolean;
    issueId: string;
    status: 'RESOLVED' | 'PENDING_VERIFY';
    nextAction: string;
    reVerifyRequired: boolean;
  } | null> {
    const session = await getSession(args.sessionId);
    if (!session) return null;
  
    // Find the issue
    const issue = session.issues.find(i => i.id === args.issueId);
    if (!issue) {
      return {
        success: false,
        issueId: args.issueId,
        status: 'PENDING_VERIFY',
        nextAction: `Issue ${args.issueId} not found`,
        reVerifyRequired: false
      };
    }
  
    // Create checkpoint before fix
    await createCheckpoint(args.sessionId);
  
    // Update issue with fix information
    issue.resolution = args.fixDescription;
    issue.status = args.triggerReVerify ? 'RAISED' : 'RESOLVED';  // Keep as RAISED if re-verify needed
  
    // Add transition record
    if (!issue.transitions) {
      issue.transitions = [];
    }
    issue.transitions.push({
      type: 'REFINED',
      fromStatus: 'RAISED',
      toStatus: args.triggerReVerify ? 'RAISED' : 'RESOLVED',
      round: session.currentRound,
      reason: `Fix applied: ${args.fixDescription}`,
      triggeredBy: 'verifier',
      timestamp: new Date().toISOString()
    });
  
    await upsertIssue(args.sessionId, issue);
  
    // Refresh context for modified files
    if (args.filesModified.length > 0) {
      const updatedSession = await getSession(args.sessionId);
      if (updatedSession) {
        // Re-read modified files into context
        for (const filePath of args.filesModified) {
          // Remove old content
          updatedSession.context.files.delete(filePath);
        }
        // Re-add with updated content
        await expandContext(args.sessionId, args.filesModified, session.currentRound);
  
        // Run pre-analysis on modified files
        const preAnalysis = analyzeContextForIssues(updatedSession.context);
        const newFindings = preAnalysis
          .filter(r => args.filesModified.some((f: string) => r.file.includes(f)))
          .reduce((sum, r) => sum + r.findings.length, 0);
  
        if (newFindings > 0) {
          return {
            success: true,
            issueId: args.issueId,
            status: 'PENDING_VERIFY',
            nextAction: `Fix applied but pre-analysis found ${newFindings} new potential issues in modified files. Re-verification recommended.`,
            reVerifyRequired: true
          };
        }
      }
    }
  
    const nextAction = args.triggerReVerify
      ? 'Submit a Verifier round to verify the fix is complete and correct'
      : 'Issue marked as resolved. Continue with remaining issues or end session.';
  
    return {
      success: true,
      issueId: args.issueId,
      status: args.triggerReVerify ? 'PENDING_VERIFY' : 'RESOLVED',
      nextAction,
      reVerifyRequired: args.triggerReVerify ?? true
    };
  }

• src/tools/schemas.ts:171-177 (schema)

  Zod schema for the ApplyFix tool: sessionId, issueId, fixDescription, filesModified (array of strings), and optional triggerReVerify (default true).

  export const ApplyFixSchema = z.object({
    sessionId: z.string().describe('Session ID'),
    issueId: z.string().describe('Issue ID being fixed'),
    fixDescription: z.string().describe('Description of the fix applied'),
    filesModified: z.array(z.string()).describe('List of files modified'),
    triggerReVerify: z.boolean().optional().default(true).describe('Whether to trigger re-verification after fix')
  });

• src/tools/issue-management.ts:188-192 (registration)

  Registers 'elenchus_apply_fix' in the issueManagementTools dictionary with description, ApplyFixSchema, and applyFix handler.

  elenchus_apply_fix: {
    description: 'Apply a fix for an issue within the current session. Creates checkpoint, updates issue status, refreshes file context, and optionally triggers re-verification. Use this to maintain fix-verify continuity without starting new sessions.',
    schema: ApplyFixSchema,
    handler: applyFix
  }

• src/tools/index.ts:41-54 (registration)

  The tools object composes issueManagementTools (which includes elenchus_apply_fix) along with other tool modules.

  export const tools = {
    ...sessionLifecycleTools,
    ...issueManagementTools,
    ...mediatorTools,
    ...roleTools,
    ...reverifyTools,
    ...diffTools,
    ...cacheTools,
    ...pipelineTools,
    ...safeguardsTools,
    ...optimizationTools,
    ...dynamicRoleTools,
    ...llmEvalTools,
  };

• src/tools/index.ts:28-28 (helper)

  Re-exports the applyFix handler function for direct imports from the tools package.

  export { getIssues, checkpoint, rollback, applyFix } from './issue-management.js';