@debugai/mcp 2.2.0 → 2.3.0

package/dist/backend.d.ts

@@ -44,6 +44,15 @@ export interface DebugResponse {
     memory_hit?: boolean;
     memory_times_seen?: number;
     memory_fix_confirmed?: boolean;
+    /**
+     * Four-valued: 'none' | 'confirmed' | 'unproven' | 'anti_pattern'. Sent by
+     * the engine since 2026-08-21. Absent from an older engine, where
+     * memory_fix_confirmed is the whole story — and that boolean now goes false
+     * on demotion, so the degraded reading is safe rather than wrong.
+     */
+    memory_fix_state?: string;
+    /** Times a live session watched the error stop after the fix. A click does not count. */
+    memory_verified_count?: number;
 }
 export interface OutcomeRequest {
     debug_log_id: string;

package/dist/tools/debugError.js

@@ -126,9 +126,53 @@ export function registerDebugError(server, config) {
                 const seen = typeof result.memory_times_seen === 'number'
                     ? `${result.memory_times_seen}x before in this project`
                     : 'before in this project';
-                sections.push(result.memory_fix_confirmed
-                    ? `\n## Seen before\nThis error has been seen ${seen}, and a fix was confirmed working. The confirmed fix led the analysis above.`
-                    : `\n## Seen before\nThis error has been seen ${seen}. No fix has been confirmed for it yet.`);
+                // Four states, not two. Until 2026-08-21 this said "a fix was
+                // confirmed working" on the strength of somebody clicking Apply,
+                // and a fix that had been tried and FAILED was indistinguishable
+                // from one nobody had ever tried — both fell into the else branch
+                // and read "no fix has been confirmed yet". An agent reading that
+                // will happily re-propose the fix that already did not work, which
+                // is the loop this whole change exists to break.
+                //
+                // memory_fix_state is what the engine sends now. When it is absent
+                // (older engine) the boolean still decides, exactly as before.
+                const state = typeof result.memory_fix_state === 'string'
+                    ? result.memory_fix_state
+                    : (result.memory_fix_confirmed ? 'confirmed' : 'none');
+                const verified = typeof result.memory_verified_count === 'number'
+                    ? result.memory_verified_count
+                    : 0;
+                let memoryBody;
+                if (state === 'confirmed' && verified > 0) {
+                    memoryBody =
+                        `This error has been seen ${seen}. A fix for it was VERIFIED BY ` +
+                            `OBSERVATION ${verified}x: a live session watched the error stop ` +
+                            `after that fix was applied. It led the analysis above.`;
+                }
+                else if (state === 'confirmed') {
+                    memoryBody =
+                        `This error has been seen ${seen}. A fix for it was applied and ` +
+                            `accepted by a developer, though nothing has observed it working. ` +
+                            `It led the analysis above. Treat it as a strong lead, not proof.`;
+                }
+                else if (state === 'unproven') {
+                    memoryBody =
+                        `This error has been seen ${seen}. A fix was applied for it and ` +
+                            `THE ERROR HAS RECURRED ONCE SINCE, so that fix is unproven. The ` +
+                            `analysis above was told not to lead with it.`;
+                }
+                else if (state === 'anti_pattern') {
+                    memoryBody =
+                        `This error has been seen ${seen}. A fix was applied for it and ` +
+                            `THE ERROR KEPT HAPPENING. That fix did not work and the analysis ` +
+                            `above was told not to propose it again. If you are about to ` +
+                            `suggest something equivalent, the cause is somewhere it does not ` +
+                            `touch.`;
+                }
+                else {
+                    memoryBody = `This error has been seen ${seen}. No fix has been confirmed for it yet.`;
+                }
+                sections.push(`\n## Seen before\n${memoryBody}`);
             }
             const badges = [];
             // Named, not counted. "Read 2 files" is unverifiable; "read src/api.ts,
@@ -176,6 +220,7 @@ export function registerDebugError(server, config) {
                     memory_hit: result.memory_hit ?? false,
                     memory_times_seen: result.memory_times_seen ?? null,
                     memory_fix_confirmed: result.memory_fix_confirmed ?? false,
+                    memory_fix_state: result.memory_fix_state ?? null,
                     // Which files this server read off disk, if any. Empty when the
                     // agent supplied its own snippet or nothing resolved.
                     local_files_read: resolved?.files.map((f) => f.label) ?? [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@debugai/mcp",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "mcpName": "io.github.1shizaan/debugai-mcp",
   "description": "DebugAI MCP server. One command sets it up in Claude Desktop, Claude Code, Cursor, Zed, Windsurf, Cline or any MCP client: browser sign-in, no key pasting, no config editing.",
   "license": "MIT",