watchfix 0.2.2 → 0.3.0

package/dist/cli/commands/fix.js

@@ -152,7 +152,7 @@ const formatStatusLine = (result, maxAttempts) => {
         return 'Status: resolved (issue already fixed)';
     }
     const retryInfo = result.attempts < maxAttempts ? ', will retry' : ', max attempts reached';
-    return `Status: ${result.status} (attempt ${result.attempts} of ${maxAttempts}${retryInfo})`;
+    return `Status: ${result.status} (attempt ${result.attempts + 1} of ${maxAttempts}${retryInfo})`;
 };
 const formatFixOutcome = (result, verbosity, maxAttempts) => {
     if (verbosity === 'quiet') {
@@ -211,7 +211,7 @@ const checkDaemonConflict = (db, logger) => {
     if (!state) {
         return true;
     }
-    if (!isOurProcess(state.pid, state.project_root)) {
+    if (!isOurProcess(state.pid)) {
         clearWatcherState(db);
         return true;
     }

package/dist/cli/commands/show.js

@@ -56,6 +56,9 @@ const formatAnalysis = (analysis) => {
         return ['Analysis (raw):', `  ${analysis}`];
     }
     const lines = ['Analysis:'];
+    if (analysis.category) {
+        lines.push(`  Category: ${analysis.category}`);
+    }
     if (analysis.summary) {
         lines.push(`  Summary: ${analysis.summary}`);
     }
@@ -73,6 +76,10 @@ const formatAnalysis = (analysis) => {
             lines.push(`    - ${file}`);
         }
     }
+    if (analysis.remediation_guidance) {
+        lines.push('  Remediation guidance:');
+        lines.push(...analysis.remediation_guidance.split('\n').map((line) => `    ${line}`));
+    }
     if (analysis.confidence) {
         lines.push(`  Confidence: ${analysis.confidence}`);
     }

package/dist/cli/commands/status.js

@@ -13,6 +13,7 @@ const STATUS_ORDER = [
     'fixed',
     'failed',
     'ignored',
+    'deferred',
 ];
 const buildDatabasePath = (rootDir) => path.join(rootDir, '.watchfix', 'errors.db');
 const getWatcherState = (db) => db.get('SELECT pid, started_at, autonomous, project_root, command_line FROM watcher_state WHERE id = 1');
@@ -62,6 +63,16 @@ const formatActionableErrors = (errors) => {
     }
     return lines;
 };
+const formatDeferredErrors = (errors) => {
+    if (errors.length === 0) {
+        return ['Deferred errors: none'];
+    }
+    const lines = ['Deferred errors (manual action required):'];
+    for (const error of errors) {
+        lines.push(`  #${error.id} ${error.errorType} (${error.source}): ${error.message}`);
+    }
+    return lines;
+};
 export const statusCommand = async (options) => {
     const config = loadConfig(options.config);
     const dbPath = buildDatabasePath(config.project.root);
@@ -71,6 +82,7 @@ export const statusCommand = async (options) => {
             'Errors:',
             ...STATUS_ORDER.map((status) => `  ${status}: 0`),
             'Actionable errors: none',
+            'Deferred errors: none',
         ];
         process.stdout.write(`${lines.join('\n')}\n`);
         return;
@@ -81,7 +93,7 @@ export const statusCommand = async (options) => {
         checkSchemaVersion(db);
         const lines = [];
         const state = getWatcherState(db);
-        if (state && isOurProcess(state.pid, state.project_root)) {
+        if (state && isOurProcess(state.pid)) {
             const mode = state.autonomous ? 'autonomous' : 'manual';
             const uptime = formatUptime(state.started_at);
             lines.push(`Watcher: running (pid ${state.pid}, ${mode} mode, uptime ${uptime}).`);
@@ -102,6 +114,8 @@ export const statusCommand = async (options) => {
         }
         const actionable = getErrorsByStatus(db, ['pending', 'suggested']);
         lines.push(...formatActionableErrors(actionable));
+        const deferred = getErrorsByStatus(db, ['deferred']);
+        lines.push(...formatDeferredErrors(deferred));
         process.stdout.write(`${lines.join('\n')}\n`);
     }
     finally {

package/dist/cli/commands/stop.js

@@ -58,7 +58,7 @@ export const stopCommand = async (options) => {
             process.exitCode = EXIT_CODES.WATCHER_CONFLICT;
             return;
         }
-        if (!isOurProcess(state.pid, state.project_root)) {
+        if (!isOurProcess(state.pid)) {
             process.stdout.write('Stale watcher state (process no longer exists).\n');
             clearWatcherState(db);
             process.exitCode = EXIT_CODES.WATCHER_CONFLICT;

package/dist/cli/commands/watch.js

@@ -31,7 +31,7 @@ const ensureWatcherAvailable = (db, projectRoot, logger) => {
     if (!existing) {
         return true;
     }
-    if (isOurProcess(existing.pid, projectRoot)) {
+    if (isOurProcess(existing.pid)) {
         const mode = existing.autonomous ? 'autonomous' : 'manual';
         const message = `Watcher already running (pid ${existing.pid}, ${mode} mode). Use 'watchfix stop'.`;
         if (logger) {

package/dist/config/schema.d.ts

@@ -261,10 +261,13 @@ declare const configSchema: z.ZodObject<{
     }>>;
     deduplication: z.ZodDefault<z.ZodObject<{
         fixed_grace_period: z.ZodDefault<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+        deferred_grace_period: z.ZodDefault<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
     }, "strip", z.ZodTypeAny, {
         fixed_grace_period: string;
+        deferred_grace_period: string;
     }, {
         fixed_grace_period?: string | undefined;
+        deferred_grace_period?: string | undefined;
     }>>;
     patterns: z.ZodDefault<z.ZodObject<{
         match: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
@@ -324,6 +327,7 @@ declare const configSchema: z.ZodObject<{
     };
     deduplication: {
         fixed_grace_period: string;
+        deferred_grace_period: string;
     };
     patterns: {
         ignore: string[];
@@ -377,6 +381,7 @@ declare const configSchema: z.ZodObject<{
     } | undefined;
     deduplication?: {
         fixed_grace_period?: string | undefined;
+        deferred_grace_period?: string | undefined;
     } | undefined;
     patterns?: {
         ignore?: string[] | undefined;

package/dist/config/schema.js

@@ -92,6 +92,7 @@ const configSchema = z.object({
     deduplication: z
         .object({
         fixed_grace_period: durationSchema.default('10m'),
+        deferred_grace_period: durationSchema.default('1h'),
     })
         .default({}),
     patterns: z

package/dist/db/queries.d.ts

@@ -35,7 +35,7 @@ export type ErrorInsert = {
     createdAt?: string;
     updatedAt?: string;
 };
-export type ActivityAction = 'watcher_start' | 'watcher_stop' | 'error_detected' | 'error_deduplicated' | 'analysis_start' | 'analysis_complete' | 'analysis_failed' | 'analysis_timeout' | 'already_fixed_detected' | 'fix_start' | 'fix_complete' | 'fix_failed' | 'fix_timeout' | 'verification_start' | 'verification_pass' | 'verification_fail' | 'error_ignored' | 'lock_acquired' | 'lock_released' | 'lock_expired' | 'stale_recovery';
+export type ActivityAction = 'watcher_start' | 'watcher_stop' | 'error_detected' | 'error_deduplicated' | 'analysis_start' | 'analysis_complete' | 'analysis_failed' | 'analysis_timeout' | 'already_fixed_detected' | 'error_deferred' | 'deferred_reanalyzed' | 'fix_start' | 'fix_complete' | 'fix_failed' | 'fix_timeout' | 'verification_start' | 'verification_pass' | 'verification_fail' | 'error_ignored' | 'lock_acquired' | 'lock_released' | 'lock_expired' | 'stale_recovery';
 export declare function insertError(db: Database, error: ErrorInsert): number;
 export declare function getError(db: Database, id: number): ErrorRecord | null;
 export declare function getErrorByHash(db: Database, hash: string): ErrorRecord | null;

package/dist/fixer/context.d.ts

@@ -1,9 +1,32 @@
 import type { Config } from '../config/schema.js';
 import type { ErrorRecord } from '../db/queries.js';
+type RetryContext = {
+    previousAttempt: {
+        analysis?: {
+            summary: string;
+            suggested_fix: string;
+            files_to_modify: string[];
+        };
+        fix?: {
+            success: boolean;
+            summary: string;
+            files_changed?: Array<{
+                path: string;
+                change: string;
+            }>;
+        };
+        verification_failure?: {
+            type: string;
+            command?: string;
+            message?: string;
+            stderr?: string;
+        };
+    };
+};
 type GeneratedContext = {
     path: string;
     content: string;
 };
-export declare const generateAnalyzeContext: (error: ErrorRecord, config: Config, attempt: number) => GeneratedContext;
+export declare const generateAnalyzeContext: (error: ErrorRecord, config: Config, attempt: number, retryContext?: RetryContext) => GeneratedContext;
 export declare const generateFixContext: (error: ErrorRecord, analysis: string, config: Config, attempt: number) => GeneratedContext;
 export type { GeneratedContext };

package/dist/fixer/context.js

@@ -97,9 +97,52 @@ const truncateStackTraceToBytes = (stackTrace, maxBytes) => {
     const head = headBytes > 0 ? sliceUtf8ByBytes(stackTrace, headBytes, 'start') : '';
     return head ? `${head}\n${STACK_TRACE_TRUNCATION_MARKER}` : STACK_TRACE_TRUNCATION_MARKER;
 };
+const buildRetrySection = (retryContext, attempt) => {
+    const { previousAttempt } = retryContext;
+    const lines = [
+        `## IMPORTANT: This is a RETRY (Attempt ${attempt + 1})`,
+        '',
+        'The previous fix attempt was applied but **verification failed**.',
+        '',
+        '### What was tried:',
+    ];
+    if (previousAttempt.analysis) {
+        lines.push(`- Analysis: ${previousAttempt.analysis.summary}`);
+        if (previousAttempt.analysis.files_to_modify.length > 0) {
+            lines.push(`- Files modified: ${previousAttempt.analysis.files_to_modify.join(', ')}`);
+        }
+    }
+    if (previousAttempt.fix) {
+        lines.push(`- Fix applied: ${previousAttempt.fix.summary}`);
+    }
+    lines.push('');
+    lines.push('### Why it failed:');
+    if (previousAttempt.verification_failure) {
+        const vf = previousAttempt.verification_failure;
+        lines.push(`**Verification command failed**: ${vf.command || 'unknown'}`);
+        lines.push(`**Message**: ${vf.message || 'unknown'}`);
+        if (vf.stderr) {
+            lines.push('**Test output**:');
+            lines.push('```');
+            lines.push(vf.stderr.slice(0, 2000));
+            lines.push('```');
+        }
+    }
+    else {
+        lines.push('Verification failed (details not available)');
+    }
+    lines.push('');
+    lines.push('### Instructions for retry:');
+    lines.push('1. The code has ALREADY been modified by the previous attempt');
+    lines.push('2. Do NOT report already_fixed unless the verification test is actually passing');
+    lines.push('3. Focus on the verification failure output - it shows what\'s still broken');
+    lines.push('4. The original error message may not appear in code anymore, but the test is still failing');
+    lines.push('');
+    return lines.join('\n');
+};
 const buildAnalyzeContent = (options) => {
     const { projectName, projectRoot, error, attempt, date, stackTrace } = options;
-    const analysisPath = path.posix.join(CONTEXT_DIR, `${date}-error-${error.id}-attempt-${attempt}-analysis.yaml`);
+    const analysisPath = path.posix.join(CONTEXT_DIR, `${date}-error-${error.id}-attempt-${attempt + 1}-analysis.yaml`);
     return `# WatchFix Task
 
 ## Mode
@@ -114,7 +157,7 @@ analyze
 - Source: ${error.source}
 - Type: ${error.errorType}
 - Detected: ${error.timestamp}
-- Fix Attempts: ${error.fixAttempts}
+- Fix Attempts: ${error.fixAttempts + 1}
 
 ### Message
 ${error.message}
@@ -124,27 +167,69 @@ ${stackTrace}
 
 ### Context (surrounding log lines)
 ${options.contextBlock}
+${options.retryContext ? `
+${buildRetrySection(options.retryContext, options.attempt)}` : ''}
+## Error Classification
+
+First, classify this error into one of three categories:
+
+**code** - Bugs in source code fixable by modifying code files:
+- Logic errors, null pointer exceptions, type mismatches
+- Missing error handling, incorrect API usage
+- Syntax errors, import/export issues
+
+**infrastructure** - Environment/deployment issues NOT fixable by code changes:
+- Database/Redis/queue unavailable or connection refused
+- Network connectivity issues, DNS resolution failures
+- Resource exhaustion (disk full, out of memory)
+- Container/orchestration problems, service not running
+
+**configuration** - Settings or config issues NOT fixable by code changes:
+- Missing or incorrect environment variables
+- Wrong config file values, invalid credentials
+- Permission issues, file/directory access denied
+- SSL/TLS certificate problems
 
 ## Instructions
 
-1. **First, check if this issue still exists in the code**
+1. **Classify the error category first**
+   - If infrastructure or configuration: provide remediation_guidance for the user
+   - Only code errors will proceed to the fix phase
+
+2. **Check if this issue still exists in the code** (for code errors)
    - Look at the file(s) mentioned in the stack trace
-   - Determine if the error condition is still present
-   - If the code has been modified and the issue is gone, report it as already_fixed
+   - If the code has been fixed, report already_fixed: true
+
+3. **Trace the root cause** (not just the symptom):
+   - Ask WHY the error occurs, not just WHERE
+   - Common root causes to check:
+     - Type mismatches in comparisons (e.g., comparing incompatible types)
+     - Failed lookups due to incorrect comparison logic
+     - Missing type conversions on input values
+   - Follow the data flow from source to error location
+   - The fix should address the underlying cause, not just guard against the symptom
 
-2. If the issue still exists:
-   - Investigate the project structure to understand the codebase
-   - Identify the root cause of this error
-   - Determine what files need to be modified
-   - Assess your confidence in the fix
+4. **Determine the minimal fix location**:
+   - Fix at the point where the bug originates, not where it manifests
+   - For type issues: convert types at the source
+   - For unhandled errors: add error handling at the CALL SITE only
+   - Do NOT modify functions that throw errors - handle errors where they are called
+
+## Anti-patterns to Avoid
+- Adding null/undefined checks that mask the real bug (e.g., the check passes but the lookup logic is still wrong)
+- Modifying error-throwing functions instead of handling at call sites
+- Adding environment variables, feature flags, or extra parameters
+- Refactoring or improving code beyond the specific fix
 
 Write your analysis to: \`${analysisPath}\`
 
 Use this exact YAML format:
 \`\`\`yaml
 already_fixed: true | false
+category: code | infrastructure | configuration
 summary: One sentence summary of the problem (or that it was already fixed)
-# The following fields are only required if already_fixed is false:
+
+# For code errors (category: code), include these fields:
 root_cause: |
   Detailed explanation of root cause
   Can be multiple lines
@@ -155,6 +240,13 @@ files_to_modify:
   - path/to/file1
   - path/to/file2
 confidence: high | medium | low
+
+# For non-code errors (category: infrastructure or configuration), include:
+remediation_guidance: |
+  Steps the user should take to resolve this issue.
+  Be specific about what to check or change.
+  Example: "Start the PostgreSQL container with: docker-compose up -d postgres"
+confidence: high | medium | low
 \`\`\`
 
 ## Constraints
@@ -163,11 +255,12 @@ confidence: high | medium | low
 - Be specific about file paths relative to project root
 - Set already_fixed to true if the issue no longer exists in the code (e.g., fixed by a previous error fix)
 - WARNING: If a fix fails and is retried, any file modifications from previous attempts will persist
+- For infrastructure/configuration errors, provide actionable remediation_guidance
 `;
 };
 const buildFixContent = (options) => {
     const { projectName, projectRoot, error, attempt, date, stackTrace, analysis } = options;
-    const resultPath = path.posix.join(CONTEXT_DIR, `${date}-error-${error.id}-attempt-${attempt}-result.yaml`);
+    const resultPath = path.posix.join(CONTEXT_DIR, `${date}-error-${error.id}-attempt-${attempt + 1}-result.yaml`);
     return `# WatchFix Task
 
 ## Mode
@@ -182,7 +275,7 @@ fix
 - Source: ${error.source}
 - Type: ${error.errorType}
 - Detected: ${error.timestamp}
-- Fix Attempts: ${error.fixAttempts}
+- Fix Attempts: ${error.fixAttempts + 1}
 
 ### Message
 ${error.message}
@@ -215,8 +308,13 @@ notes: |
 \`\`\`
 
 ## Constraints
-- Make the smallest change that resolves the issue
-- Do NOT change unrelated code
+- Make the SMALLEST change that fixes the ROOT CAUSE
+- Fix the bug where it originates, not where symptoms appear
+- Do NOT add defensive checks that mask the real bug
+- Do NOT modify functions that throw errors - add handling at call sites
+- Do NOT add environment variables, feature flags, or new parameters
+- Do NOT refactor, improve, or clean up code beyond the fix
+- If touching more than 1-2 files or 10 lines, reconsider your approach
 - If the fix cannot be applied, set success to false and explain in notes
 - WARNING: If this fix fails verification, the modified files will remain changed for the next retry attempt
 `;
@@ -263,9 +361,9 @@ const ensureSizeLimit = (options) => {
     }
     return { content, truncatedLines, beforeLines, afterLines, stackTrace };
 };
-export const generateAnalyzeContext = (error, config, attempt) => {
+export const generateAnalyzeContext = (error, config, attempt, retryContext) => {
     const date = formatDate();
-    const contextPath = path.posix.join(CONTEXT_DIR, `${date}-error-${error.id}-attempt-${attempt}-analyze.md`);
+    const contextPath = path.posix.join(CONTEXT_DIR, `${date}-error-${error.id}-attempt-${attempt + 1}-analyze.md`);
     const maxBytes = config.cleanup.context_max_size_kb * 1024;
     const { before, after } = splitRawLog(error);
     const buildContent = (stackTraceValue, beforeLines, afterLines, truncated) => {
@@ -281,6 +379,7 @@ export const generateAnalyzeContext = (error, config, attempt) => {
             date,
             stackTrace: stackTraceValue,
             contextBlock: buildContextBlock(beforeLines, errorLines, afterLines, truncated),
+            retryContext,
         });
     };
     const stackTrace = truncateStackTrace(error.stackTrace ?? '');
@@ -345,7 +444,7 @@ const ensureFixSizeLimit = (options) => {
 };
 export const generateFixContext = (error, analysis, config, attempt) => {
     const date = formatDate();
-    const contextPath = path.posix.join(CONTEXT_DIR, `${date}-error-${error.id}-attempt-${attempt}-fix.md`);
+    const contextPath = path.posix.join(CONTEXT_DIR, `${date}-error-${error.id}-attempt-${attempt + 1}-fix.md`);
     const maxBytes = config.cleanup.context_max_size_kb * 1024;
     const stackTrace = truncateStackTrace(error.stackTrace ?? '');
     const render = (analysisValue, stackTraceValue) => buildFixContent({

package/dist/fixer/index.d.ts

@@ -25,6 +25,29 @@ type FixOrchestratorOptions = {
     logger?: Logger;
     terminalEnabled?: boolean;
 };
+export type RetryContext = {
+    previousAttempt: {
+        analysis?: {
+            summary: string;
+            suggested_fix: string;
+            files_to_modify: string[];
+        };
+        fix?: {
+            success: boolean;
+            summary: string;
+            files_changed?: Array<{
+                path: string;
+                change: string;
+            }>;
+        };
+        verification_failure?: {
+            type: string;
+            command?: string;
+            message?: string;
+            stderr?: string;
+        };
+    };
+};
 export declare class FixOrchestrator {
     private readonly db;
     private readonly config;

package/dist/fixer/index.js

@@ -51,9 +51,24 @@ const parseSuggestion = (value) => {
             suggested_fix: parsed.suggested_fix ?? '',
             files_to_modify: parsed.files_to_modify ?? [],
             confidence: parsed.confidence,
+            category: parsed.category,
+            remediation_guidance: parsed.remediation_guidance,
         };
     }
-    // For regular analyses, ensure all fields are present
+    // For non-code categories, other fields may be empty
+    if (parsed.category && parsed.category !== 'code') {
+        return {
+            already_fixed: false,
+            summary: parsed.summary,
+            root_cause: parsed.root_cause ?? '',
+            suggested_fix: parsed.suggested_fix ?? '',
+            files_to_modify: parsed.files_to_modify ?? [],
+            confidence: parsed.confidence,
+            category: parsed.category,
+            remediation_guidance: parsed.remediation_guidance,
+        };
+    }
+    // For regular code analyses, ensure all fields are present
     if (typeof parsed.root_cause !== 'string' ||
         typeof parsed.suggested_fix !== 'string' ||
         !Array.isArray(parsed.files_to_modify)) {
@@ -66,8 +81,41 @@ const parseSuggestion = (value) => {
         suggested_fix: parsed.suggested_fix,
         files_to_modify: parsed.files_to_modify,
         confidence: parsed.confidence,
+        category: parsed.category,
+        remediation_guidance: parsed.remediation_guidance,
     };
 };
+const buildRetryContext = (error) => {
+    if (error.fixAttempts === 0)
+        return undefined;
+    const previousAttempt = {};
+    // Extract analysis from suggestion
+    if (error.suggestion) {
+        try {
+            const parsed = JSON.parse(error.suggestion);
+            if (!parsed.error && parsed.summary) {
+                previousAttempt.analysis = {
+                    summary: parsed.summary,
+                    suggested_fix: parsed.suggested_fix || '',
+                    files_to_modify: parsed.files_to_modify || [],
+                };
+            }
+        }
+        catch { /* ignore */ }
+    }
+    // Extract fix result and verification failure
+    if (error.fixResult) {
+        try {
+            const parsed = JSON.parse(error.fixResult);
+            if (parsed.fix)
+                previousAttempt.fix = parsed.fix;
+            if (parsed.verification_failure)
+                previousAttempt.verification_failure = parsed.verification_failure;
+        }
+        catch { /* ignore */ }
+    }
+    return Object.keys(previousAttempt).length > 0 ? { previousAttempt } : undefined;
+};
 export class FixOrchestrator {
     db;
     config;
@@ -151,8 +199,9 @@ export class FixOrchestrator {
                     throw new UserError(`Failed to transition error ${errorId} into analyzing status`);
                 }
                 logActivity(this.db, 'analysis_start', errorId, JSON.stringify({ attempt: attempts, lockId }));
-                this.logger.info(`Analyzing error ${errorId} (attempt ${attempts})...`);
-                const context = generateAnalyzeContext(error, this.config, attempts);
+                this.logger.info(`Analyzing error ${errorId} (attempt ${attempts + 1})...`);
+                const retryContext = buildRetryContext(error);
+                const context = generateAnalyzeContext(error, this.config, attempts, retryContext);
                 const contextPath = path.resolve(this.config.project.root, context.path);
                 await fs.mkdir(path.dirname(contextPath), { recursive: true });
                 await fs.writeFile(contextPath, context.content, 'utf8');
@@ -185,6 +234,34 @@ export class FixOrchestrator {
                             message: 'Issue already fixed',
                         };
                     }
+                    // Handle non-code errors by transitioning to deferred status
+                    const category = analysisOutput.category ?? 'code';
+                    if (category !== 'code') {
+                        if (!transitionStatus(this.db, errorId, 'analyzing', 'deferred', lockId)) {
+                            throw new UserError(`Failed to transition error ${errorId} into deferred status`);
+                        }
+                        this.db.run('UPDATE errors SET suggestion = ?, updated_at = ? WHERE id = ?', [
+                            JSON.stringify(analysisOutput),
+                            new Date().toISOString(),
+                            errorId,
+                        ]);
+                        logActivity(this.db, 'error_deferred', errorId, JSON.stringify({
+                            attempt: attempts,
+                            category,
+                            summary: analysisOutput.summary,
+                        }));
+                        this.logger.info(`Error ${errorId} deferred (category=${category}): ${analysisOutput.summary}`);
+                        await releaseLock(this.db, errorId, lockId);
+                        lockHeld = false;
+                        return {
+                            errorId,
+                            status: 'deferred',
+                            lockAcquired: true,
+                            attempts,
+                            analysis: analysisOutput,
+                            message: `Error deferred (${category})`,
+                        };
+                    }
                     if (!transitionStatus(this.db, errorId, 'analyzing', 'suggested', lockId)) {
                         throw new UserError(`Failed to transition error ${errorId} into suggested status`);
                     }
@@ -279,7 +356,7 @@ export class FixOrchestrator {
                 throw new UserError(`Failed to transition error ${errorId} into fixing status`);
             }
             logActivity(this.db, 'fix_start', errorId, JSON.stringify({ attempt: attempts, lockId }));
-            this.logger.info(`Applying fix for error ${errorId} (attempt ${attempts})...`);
+            this.logger.info(`Applying fix for error ${errorId} (attempt ${attempts + 1})...`);
             const analysisYaml = analysisToYaml(analysisOutput);
             const fixContext = generateFixContext(error, analysisYaml, this.config, attempts);
             const fixContextPath = path.resolve(this.config.project.root, fixContext.path);
@@ -362,14 +439,16 @@ export class FixOrchestrator {
                 if (!transitionStatus(this.db, errorId, 'fixing', 'fixed', lockId)) {
                     throw new UserError(`Failed to transition error ${errorId} into fixed status`);
                 }
-                logActivity(this.db, 'verification_pass', errorId, JSON.stringify({ attempt: attempts }));
+                const newAttempts = attempts + 1;
+                this.db.run('UPDATE errors SET fix_attempts = ?, updated_at = ? WHERE id = ?', [newAttempts, new Date().toISOString(), errorId]);
+                logActivity(this.db, 'verification_pass', errorId, JSON.stringify({ attempt: newAttempts }));
                 await releaseLock(this.db, errorId, lockId);
                 lockHeld = false;
                 return {
                     errorId,
                     status: 'fixed',
                     lockAcquired: true,
-                    attempts,
+                    attempts: newAttempts,
                     analysis: analysisOutput,
                     fix: fixOutput,
                     verification: verificationResult,
@@ -382,7 +461,18 @@ export class FixOrchestrator {
             if (!transitionStatus(this.db, errorId, 'fixing', nextStatus, lockId)) {
                 throw new UserError(`Failed to transition error ${errorId} after verification failure`);
             }
-            this.db.run('UPDATE errors SET fix_attempts = ?, updated_at = ? WHERE id = ?', [newAttempts, new Date().toISOString(), errorId]);
+            const failureRecord = {
+                fix: fixOutput,
+                verification_failure: verificationResult.failure ? {
+                    type: verificationResult.failure.type,
+                    command: verificationResult.failure.type === 'command'
+                        ? verificationResult.failure.command : undefined,
+                    message: verificationResult.failure.message,
+                    stderr: verificationResult.failure.type === 'command'
+                        ? verificationResult.failure.stderr?.slice(0, 4096) : undefined,
+                } : undefined,
+            };
+            this.db.run('UPDATE errors SET fix_result = ?, fix_attempts = ?, updated_at = ? WHERE id = ?', [JSON.stringify(failureRecord), newAttempts, new Date().toISOString(), errorId]);
             logActivity(this.db, 'verification_fail', errorId, JSON.stringify({ attempt: attempts, failure: verificationResult.failure }));
             await releaseLock(this.db, errorId, lockId);
             lockHeld = false;

package/dist/fixer/output.d.ts

@@ -1,4 +1,5 @@
 type ConfidenceLevel = 'high' | 'medium' | 'low';
+type ErrorCategory = 'code' | 'infrastructure' | 'configuration';
 type AnalysisOutput = {
     already_fixed: boolean;
     summary: string;
@@ -6,6 +7,8 @@ type AnalysisOutput = {
     suggested_fix: string;
     files_to_modify: string[];
     confidence: ConfidenceLevel;
+    category?: ErrorCategory;
+    remediation_guidance?: string;
 };
 type FixOutput = {
     success: boolean;
@@ -16,7 +19,18 @@ type FixOutput = {
     }>;
     notes?: string;
 };
+type StoredFixResult = {
+    fix?: FixOutput;
+    verification_failure?: {
+        type: 'command' | 'health_check';
+        command?: string;
+        message?: string;
+        stderr?: string;
+    };
+    error?: boolean;
+    diagnostic?: string;
+};
 declare const parseAnalysisOutput: (content: string) => AnalysisOutput;
 declare const parseFixOutput: (content: string) => FixOutput;
-export type { AnalysisOutput, FixOutput, ConfidenceLevel };
+export type { AnalysisOutput, FixOutput, ConfidenceLevel, ErrorCategory, StoredFixResult };
 export { parseAnalysisOutput, parseFixOutput };

package/dist/fixer/output.js

@@ -66,12 +66,30 @@ const validateConfidence = (value) => {
     }
     throw new UserError(`Invalid confidence value: ${value ?? 'undefined'} (expected high|medium|low)`);
 };
+const validateCategory = (value) => {
+    if (value === 'code' || value === 'infrastructure' || value === 'configuration') {
+        return value;
+    }
+    throw new UserError(`Invalid category value: ${value ?? 'undefined'} (expected code|infrastructure|configuration)`);
+};
 const parseAnalysisOutput = (content) => {
     const raw = parseYaml(content);
     const data = assertRecord(raw);
     const already_fixed = data.already_fixed === true;
     const summary = requireStringField(data, 'summary');
     const confidence = validateConfidence(data.confidence);
+    // Parse category, defaulting to 'code' if not specified (backwards compat)
+    const category = data.category !== undefined
+        ? validateCategory(data.category)
+        : 'code';
+    // Parse remediation_guidance if present
+    let remediation_guidance;
+    if (data.remediation_guidance !== undefined) {
+        if (typeof data.remediation_guidance !== 'string') {
+            throw new UserError('Invalid field: remediation_guidance must be a string');
+        }
+        remediation_guidance = data.remediation_guidance;
+    }
     if (already_fixed) {
         return {
             already_fixed: true,
@@ -80,8 +98,31 @@ const parseAnalysisOutput = (content) => {
             suggested_fix: '',
             files_to_modify: [],
             confidence,
+            category,
+            remediation_guidance,
+        };
+    }
+    // For non-code categories, require remediation_guidance but allow empty files_to_modify
+    if (category !== 'code') {
+        if (!remediation_guidance || remediation_guidance.trim() === '') {
+            throw new UserError(`Missing required field: remediation_guidance (required for ${category} errors)`);
+        }
+        // files_to_modify can be empty for non-code errors
+        const files_to_modify = data.files_to_modify !== undefined
+            ? requireStringArrayField(data, 'files_to_modify')
+            : [];
+        return {
+            already_fixed: false,
+            summary,
+            root_cause: typeof data.root_cause === 'string' ? data.root_cause : '',
+            suggested_fix: typeof data.suggested_fix === 'string' ? data.suggested_fix : '',
+            files_to_modify,
+            confidence,
+            category,
+            remediation_guidance,
         };
     }
+    // For code category, require root_cause, suggested_fix, files_to_modify
     const root_cause = requireStringField(data, 'root_cause');
     const suggested_fix = requireStringField(data, 'suggested_fix');
     const files_to_modify = requireStringArrayField(data, 'files_to_modify');
@@ -92,6 +133,8 @@ const parseAnalysisOutput = (content) => {
         suggested_fix,
         files_to_modify,
         confidence,
+        category,
+        remediation_guidance,
     };
 };
 const parseFixOutput = (content) => {

package/dist/utils/errors.d.ts

@@ -6,7 +6,7 @@ export declare class InternalError extends Error {
         cause?: unknown;
     });
 }
-export type ErrorStatus = 'pending' | 'analyzing' | 'suggested' | 'fixing' | 'fixed' | 'failed' | 'ignored' | 'resolved';
+export type ErrorStatus = 'pending' | 'analyzing' | 'suggested' | 'fixing' | 'fixed' | 'failed' | 'ignored' | 'resolved' | 'deferred';
 export declare const EXIT_CODES: {
     readonly SUCCESS: 0;
     readonly GENERAL_ERROR: 1;

package/dist/utils/process.d.ts

@@ -13,4 +13,4 @@ export interface SpawnResult {
 }
 export declare function checkCliExists(command: string): CliCheckResult;
 export declare function spawnWithTimeout(command: string, args: string[], options: SpawnOptions | undefined, timeoutMs: number): Promise<SpawnResult>;
-export declare function isOurProcess(pid: number, expectedRoot: string): boolean;
+export declare function isOurProcess(pid: number): boolean;

package/dist/utils/process.js

@@ -126,7 +126,7 @@ function readCommandLine(pid) {
     });
     return `${result.stdout ?? ''}${result.stderr ?? ''}`.trim();
 }
-export function isOurProcess(pid, expectedRoot) {
+export function isOurProcess(pid) {
     try {
         process.kill(pid, 0);
     }
@@ -138,7 +138,8 @@ export function isOurProcess(pid, expectedRoot) {
         if (!cmdline) {
             return false;
         }
-        return cmdline.includes('watchfix') && cmdline.includes(expectedRoot);
+        // Check for 'watchfix' in command line, or 'index.js' for dev mode
+        return cmdline.includes('watchfix') || cmdline.includes('index.js');
     }
     catch {
         return false;

package/dist/watcher/index.js

@@ -203,6 +203,25 @@ export class WatcherOrchestrator {
                     return;
                 }
             }
+            // Handle deferred errors with grace period
+            // Within grace period: deduplicate
+            // After grace period: create new error for re-analysis
+            if (existing && existing.status === 'deferred') {
+                const gracePeriodMs = parseDuration(this.config.deduplication.deferred_grace_period);
+                const deferredAt = new Date(existing.updatedAt).getTime();
+                if (Date.now() - deferredAt < gracePeriodMs) {
+                    logActivity(this.db, 'error_deduplicated', existing.id, `status=${existing.status} grace_period=true`);
+                    this.logger.info(`Deduplicated error ${error.hash} (within grace period after deferral)`);
+                    this.emitter.emit('error_deduplicated', {
+                        errorId: existing.id,
+                        error,
+                        status: existing.status,
+                    });
+                    return;
+                }
+                // Grace period expired - fall through to create new error for re-analysis
+                this.logger.info(`Deferred error ${error.hash} reappeared after grace period - creating new error for re-analysis`);
+            }
             const newId = insertError(this.db, {
                 hash: error.hash,
                 source: error.source,
@@ -216,11 +235,18 @@ export class WatcherOrchestrator {
                 suggestion: null,
                 fixResult: null,
             });
-            const details = existing ? `recurrence_of=${existing.id}` : undefined;
-            logActivity(this.db, 'error_detected', newId, details);
-            this.logger.info(existing
-                ? `Recurring error detected (${newId}) from ${error.source}`
-                : `New error detected (${newId}) from ${error.source}`);
+            // Log appropriate activity based on previous status
+            if (existing && existing.status === 'deferred') {
+                logActivity(this.db, 'deferred_reanalyzed', newId, `previous_id=${existing.id}`);
+                this.logger.info(`Deferred error re-analyzed (${newId}) from ${error.source}`);
+            }
+            else {
+                const details = existing ? `recurrence_of=${existing.id}` : undefined;
+                logActivity(this.db, 'error_detected', newId, details);
+                this.logger.info(existing
+                    ? `Recurring error detected (${newId}) from ${error.source}`
+                    : `New error detected (${newId}) from ${error.source}`);
+            }
             this.emitter.emit('error_detected', {
                 errorId: newId,
                 error,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "watchfix",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "CLI tool that watches logs, detects errors, and dispatches AI agents to fix them",
   "keywords": [
     "cli",