watchfix 0.1.0 → 0.2.1

package/README.md

@@ -64,12 +64,28 @@ watchfix watch
 watchfix fix <error-id>
 ```
 
+## Autonomous Mode
+
+For fully automated error fixing without manual approval:
+
+```bash
+watchfix watch --autonomous
+```
+
+In autonomous mode, watchfix automatically dispatches AI agents to fix detected errors. Combine with daemon mode for background operation (Linux/macOS):
+
+```bash
+watchfix watch --daemon --autonomous
+```
+
+**Note:** Manual `watchfix fix` commands are blocked while running in autonomous mode.
+
 ## CLI Commands
 
 | Command | Description |
 |---------|-------------|
 | `watchfix init` | Create `watchfix.yaml` in current directory |
-| `watchfix watch` | Watch logs in foreground (use `--daemon` for background) |
+| `watchfix watch` | Watch logs in foreground (use `--daemon` for background, `--autonomous` for auto-fix) |
 | `watchfix fix [id]` | Analyze and fix a specific error (or `--all` for all pending) |
 | `watchfix show <id>` | Show full error details and analysis |
 | `watchfix status` | Show watcher state and pending errors |
@@ -94,6 +110,8 @@ watchfix fix <error-id>
 
 For detailed configuration options and advanced usage, see the [specification document](./spec/watchfix-spec-v8.md).
 
+For a working example project, see [watchfix-example](https://github.com/CaseyHaralson/watchfix-example).
+
 ## License
 
 [MIT](./LICENSE)

package/dist/cli/commands/fix.js

@@ -39,13 +39,34 @@ const parseStoredAnalysis = (value) => {
         const parsed = JSON.parse(value);
         if (!parsed ||
             typeof parsed.summary !== 'string' ||
-            typeof parsed.root_cause !== 'string' ||
-            typeof parsed.suggested_fix !== 'string' ||
-            !Array.isArray(parsed.files_to_modify) ||
             typeof parsed.confidence !== 'string') {
             return null;
         }
-        return parsed;
+        // For already_fixed analyses, root_cause/suggested_fix/files_to_modify may be empty
+        if (parsed.already_fixed === true) {
+            return {
+                already_fixed: true,
+                summary: parsed.summary,
+                root_cause: parsed.root_cause ?? '',
+                suggested_fix: parsed.suggested_fix ?? '',
+                files_to_modify: parsed.files_to_modify ?? [],
+                confidence: parsed.confidence,
+            };
+        }
+        // For regular analyses, ensure all fields are present
+        if (typeof parsed.root_cause !== 'string' ||
+            typeof parsed.suggested_fix !== 'string' ||
+            !Array.isArray(parsed.files_to_modify)) {
+            return null;
+        }
+        return {
+            already_fixed: parsed.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,
+        };
     }
     catch {
         return null;
@@ -54,6 +75,11 @@ const parseStoredAnalysis = (value) => {
 const formatAnalysisSummary = (analysis) => {
     const lines = ['Analysis summary:'];
     lines.push(`  Summary: ${analysis.summary}`);
+    if (analysis.already_fixed) {
+        lines.push('  Status: Issue already fixed (no action needed)');
+        lines.push(`  Confidence: ${analysis.confidence}`);
+        return lines;
+    }
     lines.push('  Root cause:');
     lines.push(...analysis.root_cause.split('\n').map((line) => `    ${line}`));
     lines.push('  Suggested fix:');
@@ -87,11 +113,98 @@ const promptForConfirmation = async (label) => {
         rl.close();
     }
 };
-const formatFixFailure = (result) => {
-    if (result.verification?.failure) {
-        return result.verification.failure.message;
+const formatFilesChanged = (files, indent = '  ') => {
+    if (!files || files.length === 0) {
+        return [`${indent}(no files changed)`];
+    }
+    return files.map((f) => `${indent}- ${f.path}: ${f.change}`);
+};
+const formatVerificationSummary = (result, verbosity) => {
+    if (!result) {
+        return ['  Verification: not run'];
+    }
+    if (result.success) {
+        return ['  Verification: PASSED'];
+    }
+    const lines = ['  Verification: FAILED'];
+    if (result.failure) {
+        lines.push(`    ${result.failure.message}`);
+        if (verbosity === 'verbose' && result.failure.type === 'command') {
+            const stdout = result.failure.stdout.trim();
+            const stderr = result.failure.stderr.trim();
+            if (stdout) {
+                lines.push('    stdout:');
+                lines.push(...stdout.split('\n').map((line) => `      ${line}`));
+            }
+            if (stderr) {
+                lines.push('    stderr:');
+                lines.push(...stderr.split('\n').map((line) => `      ${line}`));
+            }
+        }
+    }
+    return lines;
+};
+const formatStatusLine = (result, maxAttempts) => {
+    if (result.status === 'fixed') {
+        return 'Status: fixed';
     }
-    return result.message ?? 'Fix did not complete successfully.';
+    if (result.status === 'resolved') {
+        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})`;
+};
+const formatFixOutcome = (result, verbosity, maxAttempts) => {
+    if (verbosity === 'quiet') {
+        if (result.status === 'fixed') {
+            return [`Error #${result.errorId}: fixed`];
+        }
+        if (result.status === 'resolved') {
+            return [`Error #${result.errorId}: resolved (already fixed)`];
+        }
+        const mode = result.fix?.success ? 'verification' : 'agent';
+        return [`Error #${result.errorId}: failed (${mode})`];
+    }
+    const lines = [];
+    // Header
+    if (result.status === 'fixed') {
+        lines.push(`Error #${result.errorId}: Fix verified successfully`);
+    }
+    else if (result.status === 'resolved') {
+        lines.push(`Error #${result.errorId}: Issue already fixed`);
+    }
+    else if (!result.fix?.success) {
+        lines.push(`Error #${result.errorId}: Agent could not apply fix`);
+        if (result.diagnostic) {
+            // Extract key info from diagnostic
+            const diagLines = result.diagnostic.split('\n');
+            const reason = diagLines.find(l => l.includes('timed out') || l.includes('Exit code'));
+            if (reason) {
+                lines.push(`  Reason: ${reason.trim()}`);
+            }
+        }
+    }
+    else {
+        lines.push(`Error #${result.errorId}: Fix attempt completed`);
+    }
+    // Agent details
+    if (result.fix) {
+        lines.push(`  Agent applied fix: ${result.fix.success ? 'yes' : 'no'}`);
+        if (result.fix.files_changed?.length) {
+            lines.push('  Files changed:');
+            lines.push(...formatFilesChanged(result.fix.files_changed, '    '));
+        }
+        if (result.fix.notes && (verbosity === 'verbose' || !result.fix.success)) {
+            lines.push(`  Agent notes: ${result.fix.notes}`);
+        }
+    }
+    // Verification
+    if (result.verification) {
+        lines.push(...formatVerificationSummary(result.verification, verbosity));
+    }
+    lines.push('');
+    lines.push(formatStatusLine(result, maxAttempts));
+    return lines;
 };
 const checkDaemonConflict = (db, logger) => {
     const state = getWatcherState(db);
@@ -138,20 +251,23 @@ const reportAnalysisFromResult = (db, errorId, result, note) => {
         parseStoredAnalysis(getError(db, errorId)?.suggestion ?? null);
     reportAnalysis(errorId, analysis, note);
 };
-const reportFixResult = (result) => {
+const reportFixResult = (result, verbosity = 'normal', maxAttempts = 3) => {
     if (!result.lockAcquired) {
         process.stdout.write(`Skipped error #${result.errorId}: already locked by another process.\n`);
         return 'skipped';
     }
+    const lines = formatFixOutcome(result, verbosity, maxAttempts);
+    process.stdout.write(`${lines.join('\n')}\n`);
     if (result.status === 'fixed') {
-        process.stdout.write(`✓ Error #${result.errorId} fixed successfully.\n`);
         return 'fixed';
     }
-    const message = formatFixFailure(result);
-    process.stdout.write(`✗ Error #${result.errorId} not fixed (status=${result.status}).\n${message}\n`);
+    if (result.status === 'resolved') {
+        return 'resolved';
+    }
     return 'failed';
 };
-const runSingleFix = async (db, error, options, orchestrator) => {
+const runSingleFix = async (db, error, options, orchestrator, ctx) => {
+    const { verbosity, maxAttempts } = ctx;
     const reanalyze = Boolean(options.reanalyze);
     const analyzeOnly = Boolean(options.analyzeOnly);
     const shouldPrompt = !options.yes && !analyzeOnly;
@@ -163,11 +279,11 @@ const runSingleFix = async (db, error, options, orchestrator) => {
         });
         if (!result.lockAcquired) {
             process.exitCode = EXIT_CODES.NOT_ACTIONABLE;
-            return reportFixResult(result);
+            return reportFixResult(result, verbosity, maxAttempts);
         }
         if (result.status !== 'suggested') {
             process.exitCode = EXIT_CODES.GENERAL_ERROR;
-            reportFixResult(result);
+            reportFixResult(result, verbosity, maxAttempts);
             return 'failed';
         }
         reportAnalysis(error.id, result.analysis ??
@@ -184,7 +300,7 @@ const runSingleFix = async (db, error, options, orchestrator) => {
             });
             if (!analysisResult.lockAcquired) {
                 process.exitCode = EXIT_CODES.NOT_ACTIONABLE;
-                return reportFixResult(analysisResult);
+                return reportFixResult(analysisResult, verbosity, maxAttempts);
             }
             analysisNote = analysisResult.message;
             analysis =
@@ -192,7 +308,7 @@ const runSingleFix = async (db, error, options, orchestrator) => {
                     parseStoredAnalysis(getError(db, error.id)?.suggestion ?? null);
             if (analysisResult.status !== 'suggested') {
                 process.exitCode = EXIT_CODES.GENERAL_ERROR;
-                return reportFixResult(analysisResult);
+                return reportFixResult(analysisResult, verbosity, maxAttempts);
             }
             reanalyzeForFix = false;
         }
@@ -213,15 +329,16 @@ const runSingleFix = async (db, error, options, orchestrator) => {
     });
     if (!result.lockAcquired) {
         process.exitCode = EXIT_CODES.NOT_ACTIONABLE;
-        return reportFixResult(result);
+        return reportFixResult(result, verbosity, maxAttempts);
     }
     reportAnalysisFromResult(db, error.id, result);
-    if (result.status !== 'fixed') {
+    if (result.status !== 'fixed' && result.status !== 'resolved') {
         process.exitCode = EXIT_CODES.GENERAL_ERROR;
     }
-    return reportFixResult(result);
+    return reportFixResult(result, verbosity, maxAttempts);
 };
-const runAllFixes = async (db, options, orchestrator) => {
+const runAllFixes = async (db, options, orchestrator, ctx) => {
+    const { verbosity, maxAttempts } = ctx;
     const errors = getErrorsByStatus(db, FIXABLE_STATUSES);
     if (errors.length === 0) {
         process.stdout.write('No pending or suggested errors to fix.\n');
@@ -234,6 +351,7 @@ const runAllFixes = async (db, options, orchestrator) => {
     let failedCount = 0;
     let skippedCount = 0;
     let analyzedCount = 0;
+    let resolvedCount = 0;
     for (const error of errors) {
         const fixabilityIssue = ensureFixable(error);
         if (fixabilityIssue) {
@@ -248,12 +366,17 @@ const runAllFixes = async (db, options, orchestrator) => {
             });
             if (!result.lockAcquired) {
                 skippedCount += 1;
-                reportFixResult(result);
+                reportFixResult(result, verbosity, maxAttempts);
+                continue;
+            }
+            if (result.status === 'resolved') {
+                resolvedCount += 1;
+                reportFixResult(result, verbosity, maxAttempts);
                 continue;
             }
             if (result.status !== 'suggested') {
                 failedCount += 1;
-                reportFixResult(result);
+                reportFixResult(result, verbosity, maxAttempts);
                 continue;
             }
             reportAnalysis(error.id, result.analysis ?? parseStoredAnalysis(getError(db, error.id)?.suggestion ?? null), result.message);
@@ -271,16 +394,21 @@ const runAllFixes = async (db, options, orchestrator) => {
                 });
                 if (!analysisResult.lockAcquired) {
                     skippedCount += 1;
-                    reportFixResult(analysisResult);
+                    reportFixResult(analysisResult, verbosity, maxAttempts);
                     continue;
                 }
                 note = analysisResult.message;
                 analysis =
                     analysisResult.analysis ??
                         parseStoredAnalysis(getError(db, error.id)?.suggestion ?? null);
+                if (analysisResult.status === 'resolved') {
+                    resolvedCount += 1;
+                    reportFixResult(analysisResult, verbosity, maxAttempts);
+                    continue;
+                }
                 if (analysisResult.status !== 'suggested') {
                     failedCount += 1;
-                    reportFixResult(analysisResult);
+                    reportFixResult(analysisResult, verbosity, maxAttempts);
                     continue;
                 }
                 reanalyzeForFix = false;
@@ -302,36 +430,43 @@ const runAllFixes = async (db, options, orchestrator) => {
             });
             if (!result.lockAcquired) {
                 skippedCount += 1;
-                reportFixResult(result);
+                reportFixResult(result, verbosity, maxAttempts);
                 continue;
             }
             if (result.status === 'fixed') {
                 fixedCount += 1;
             }
+            else if (result.status === 'resolved') {
+                resolvedCount += 1;
+            }
             else {
                 failedCount += 1;
             }
-            reportFixResult(result);
+            reportFixResult(result, verbosity, maxAttempts);
             continue;
         }
         const result = await orchestrator.fixError(error.id, { reanalyze });
         if (!result.lockAcquired) {
             skippedCount += 1;
-            reportFixResult(result);
+            reportFixResult(result, verbosity, maxAttempts);
             continue;
         }
         reportAnalysisFromResult(db, error.id, result);
         if (result.status === 'fixed') {
             fixedCount += 1;
         }
+        else if (result.status === 'resolved') {
+            resolvedCount += 1;
+        }
         else {
             failedCount += 1;
         }
-        reportFixResult(result);
+        reportFixResult(result, verbosity, maxAttempts);
     }
+    const resolvedSuffix = resolvedCount > 0 ? `, resolved ${resolvedCount}` : '';
     const summary = analyzeOnly
-        ? `Analyzed ${analyzedCount} errors, failed ${failedCount}, skipped ${skippedCount}.`
-        : `Summary: fixed ${fixedCount}, failed ${failedCount}, skipped ${skippedCount}.`;
+        ? `Analyzed ${analyzedCount} errors, failed ${failedCount}, skipped ${skippedCount}${resolvedSuffix}.`
+        : `Summary: fixed ${fixedCount}, failed ${failedCount}, skipped ${skippedCount}${resolvedSuffix}.`;
     process.stdout.write(`${summary}\n`);
     if (!analyzeOnly && failedCount > 0) {
         process.exitCode = EXIT_CODES.GENERAL_ERROR;
@@ -366,8 +501,12 @@ export const fixCommand = async (id, options) => {
             logger,
             terminalEnabled: true,
         });
+        const ctx = {
+            verbosity,
+            maxAttempts: config.limits.max_attempts_per_error,
+        };
         if (options.all) {
-            await runAllFixes(db, options, orchestrator);
+            await runAllFixes(db, options, orchestrator, ctx);
             return;
         }
         const errorId = parsePositiveInt(id);
@@ -383,7 +522,7 @@ export const fixCommand = async (id, options) => {
             process.exitCode = EXIT_CODES.NOT_ACTIONABLE;
             return;
         }
-        await runSingleFix(db, error, options, orchestrator);
+        await runSingleFix(db, error, options, orchestrator, ctx);
     }
     finally {
         db.close();

package/dist/cli/commands/watch.js

@@ -197,6 +197,7 @@ export const watchCommand = async (options) => {
         clearWatcherState: () => clearWatcherState(db),
     });
     await watcher.start();
+    logger.info('Watching for errors... (Ctrl+C to stop)');
     if (options.autonomous) {
         void fixQueue?.processQueueIfReady();
     }

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' | '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' | '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.js

@@ -127,16 +127,24 @@ ${options.contextBlock}
 
 ## Instructions
 
-1. Investigate the project structure to understand the codebase
-2. Identify the root cause of this error
-3. Determine what files need to be modified
-4. Assess your confidence in the fix
+1. **First, check if this issue still exists in the code**
+   - 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
+
+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
 
 Write your analysis to: \`${analysisPath}\`
 
 Use this exact YAML format:
 \`\`\`yaml
-summary: One sentence summary of the problem
+already_fixed: true | false
+summary: One sentence summary of the problem (or that it was already fixed)
+# The following fields are only required if already_fixed is false:
 root_cause: |
   Detailed explanation of root cause
   Can be multiple lines
@@ -153,6 +161,7 @@ confidence: high | medium | low
 - Do NOT modify any files during analysis
 - If you cannot determine the cause, set confidence to "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
 `;
 };

package/dist/fixer/index.d.ts

@@ -18,6 +18,7 @@ export type FixResult = {
     fix?: FixOutput;
     verification?: VerificationResult;
     message?: string;
+    diagnostic?: string;
 };
 type FixOrchestratorOptions = {
     agent?: Agent;

package/dist/fixer/index.js

@@ -39,13 +39,34 @@ const parseSuggestion = (value) => {
     const parsed = JSON.parse(value);
     if (!parsed ||
         typeof parsed.summary !== 'string' ||
-        typeof parsed.root_cause !== 'string' ||
-        typeof parsed.suggested_fix !== 'string' ||
-        !Array.isArray(parsed.files_to_modify) ||
         typeof parsed.confidence !== 'string') {
         throw new UserError('Stored analysis output is invalid');
     }
-    return parsed;
+    // For already_fixed analyses, other fields may be empty
+    if (parsed.already_fixed === true) {
+        return {
+            already_fixed: true,
+            summary: parsed.summary,
+            root_cause: parsed.root_cause ?? '',
+            suggested_fix: parsed.suggested_fix ?? '',
+            files_to_modify: parsed.files_to_modify ?? [],
+            confidence: parsed.confidence,
+        };
+    }
+    // For regular analyses, ensure all fields are present
+    if (typeof parsed.root_cause !== 'string' ||
+        typeof parsed.suggested_fix !== 'string' ||
+        !Array.isArray(parsed.files_to_modify)) {
+        throw new UserError('Stored analysis output is invalid');
+    }
+    return {
+        already_fixed: parsed.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,
+    };
 };
 export class FixOrchestrator {
     db;
@@ -140,6 +161,30 @@ export class FixOrchestrator {
                 const analysisResult = await this.processAgentOutput(agentResult, outputPath, parseAnalysisOutput);
                 if (analysisResult.success) {
                     analysisOutput = analysisResult.data;
+                    if (analysisOutput.already_fixed) {
+                        if (!transitionStatus(this.db, errorId, 'analyzing', 'resolved', lockId)) {
+                            throw new UserError(`Failed to transition error ${errorId} into resolved status`);
+                        }
+                        this.db.run('UPDATE errors SET suggestion = ?, updated_at = ? WHERE id = ?', [
+                            JSON.stringify(analysisOutput),
+                            new Date().toISOString(),
+                            errorId,
+                        ]);
+                        logActivity(this.db, 'already_fixed_detected', errorId, JSON.stringify({
+                            attempt: attempts,
+                            summary: analysisOutput.summary,
+                        }));
+                        await releaseLock(this.db, errorId, lockId);
+                        lockHeld = false;
+                        return {
+                            errorId,
+                            status: 'resolved',
+                            lockAcquired: true,
+                            attempts,
+                            analysis: analysisOutput,
+                            message: 'Issue already fixed',
+                        };
+                    }
                     if (!transitionStatus(this.db, errorId, 'analyzing', 'suggested', lockId)) {
                         throw new UserError(`Failed to transition error ${errorId} into suggested status`);
                     }
@@ -201,6 +246,7 @@ export class FixOrchestrator {
                         lockAcquired: true,
                         attempts,
                         message: 'Analysis failed',
+                        diagnostic: analysisResult.diagnostic,
                     };
                 }
             }
@@ -303,6 +349,7 @@ export class FixOrchestrator {
                     attempts,
                     analysis: analysisOutput,
                     message: 'Fix failed',
+                    diagnostic: fixResult.diagnostic,
                 };
             }
             logActivity(this.db, 'verification_start', errorId, JSON.stringify({ attempt: attempts }));

package/dist/fixer/output.d.ts

@@ -1,5 +1,6 @@
 type ConfidenceLevel = 'high' | 'medium' | 'low';
 type AnalysisOutput = {
+    already_fixed: boolean;
     summary: string;
     root_cause: string;
     suggested_fix: string;

package/dist/fixer/output.js

@@ -69,12 +69,24 @@ const validateConfidence = (value) => {
 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);
+    if (already_fixed) {
+        return {
+            already_fixed: true,
+            summary,
+            root_cause: '',
+            suggested_fix: '',
+            files_to_modify: [],
+            confidence,
+        };
+    }
     const root_cause = requireStringField(data, 'root_cause');
     const suggested_fix = requireStringField(data, 'suggested_fix');
     const files_to_modify = requireStringArrayField(data, 'files_to_modify');
-    const confidence = validateConfidence(data.confidence);
     return {
+        already_fixed: false,
         summary,
         root_cause,
         suggested_fix,

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';
+export type ErrorStatus = 'pending' | 'analyzing' | 'suggested' | 'fixing' | 'fixed' | 'failed' | 'ignored' | 'resolved';
 export declare const EXIT_CODES: {
     readonly SUCCESS: 0;
     readonly GENERAL_ERROR: 1;

package/dist/watcher/parser.js

@@ -11,6 +11,14 @@ const CONTINUATION_PATTERNS = [
     /^\s+\.\.\./,
 ];
 const isContinuationLine = (line) => CONTINUATION_PATTERNS.some((pattern) => pattern.test(line));
+const extractCoreMessage = (line) => {
+    // "TypeError: Cannot read..." → "Cannot read..."
+    const colonIndex = line.indexOf(': ');
+    if (colonIndex > 0 && colonIndex < 30) {
+        return line.slice(colonIndex + 2).trim();
+    }
+    return line.trim();
+};
 const truncateLine = (line) => {
     if (line.length <= MAX_LINE_LENGTH) {
         return line;
@@ -58,6 +66,21 @@ export class ErrorParser {
             return;
         }
         if (isError) {
+            // Check if this is the same error with a more specific type
+            if (this.current && this.current.stackLines.length === 0) {
+                const currentCore = extractCoreMessage(this.current.message);
+                const newCore = extractCoreMessage(line);
+                if (currentCore === newCore) {
+                    // Same error - discard shallow entry, use the more detailed one
+                    if (this.flushTimer) {
+                        clearTimeout(this.flushTimer);
+                        this.flushTimer = undefined;
+                    }
+                    this.current = undefined;
+                    this.startError(event, line);
+                    return;
+                }
+            }
             await this.flushCurrent('new_error');
             this.startError(event, line);
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "watchfix",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "CLI tool that watches logs, detects errors, and dispatches AI agents to fix them",
   "type": "module",
   "bin": {