@debugai/mcp 2.4.1 → 2.4.3

package/README.md

@@ -233,6 +233,16 @@ Recent server-side work, all of it live for agents already:
 - pytest, unittest, jest, vitest and mocha output yields real file paths, so a
   failing test gets cross-file context instead of none.
 
+**2.4.2**: the bundled server prints the memory it advertises. This package and
+the copy bundled in the VS Code extension are the same server, and only this one
+was rendering the recurrence count and confirmed fix that both of them promise an
+agent at connect time. The section is now one module both copies call, so there
+is nothing left to keep in step by hand.
+
+**2.4.1**: two tool descriptions repaired. An em-dash strip had cut both of them
+mid-sentence, which matters more here than it reads: a tool description is the
+only thing an agent sees before deciding whether to call this server at all.
+
 **2.4.0**: `report_outcome` gains `unused`. An agent that solved the problem its
 own way had to report `failed`, which marks a fix as tried and beaten when
 nothing of ours was ever run. Both tool surfaces, the npm server and the one

package/dist/memorySection.d.ts

@@ -0,0 +1,39 @@
+/**
+ * What this project already knows about this exact error.
+ *
+ * ## Why it is its own module
+ *
+ * This section was the headline of npm 2.4.0 and **never reached the bundled
+ * server** — the zero-config one VS Code registers automatically, with no
+ * install and no config, and therefore the copy an agent is most likely to be
+ * on. For weeks the most-used MCP server advertised memory in its own
+ * instructions and never printed a word of it. That is the third time a
+ * decision duplicated across this boundary has drifted in the same direction.
+ *
+ * Inlined in two `debugError.ts` files it drifted silently, because
+ * `drift.test.ts` pinned tool SIGNATURES and the signatures were identical.
+ * As a module it is byte-comparable, and that comparison now ships as a test.
+ *
+ * Mirror: apps/extension/src/mcp/memorySection.ts
+ * The two are identical below this header. Change one, change the other, on
+ * the same commit (Rule 15b).
+ */
+/** The fields the engine sends about a remembered error. Every one optional:
+ *  an older engine sends none, and absence must read as "nothing remembered"
+ *  rather than as "nothing happened". */
+export interface MemoryFields {
+    memory_hit?: boolean;
+    memory_times_seen?: number;
+    memory_fix_confirmed?: boolean;
+    memory_fix_state?: string;
+    memory_verified_count?: number;
+}
+/**
+ * The "Seen before" section, or null when there is nothing remembered.
+ *
+ * Returns null rather than an empty string so a caller cannot push a blank
+ * heading into the response and leave an agent reading "## Seen before"
+ * followed by nothing, which is worse than no section: it looks like a lookup
+ * that ran and found the error is new.
+ */
+export declare function memorySection(result: MemoryFields | null | undefined): string | null;

package/dist/memorySection.js

@@ -0,0 +1,62 @@
+/**
+ * The "Seen before" section, or null when there is nothing remembered.
+ *
+ * Returns null rather than an empty string so a caller cannot push a blank
+ * heading into the response and leave an agent reading "## Seen before"
+ * followed by nothing, which is worse than no section: it looks like a lookup
+ * that ran and found the error is new.
+ */
+export function memorySection(result) {
+    if (!result?.memory_hit) {
+        return null;
+    }
+    const seen = typeof result.memory_times_seen === 'number'
+        ? `${result.memory_times_seen}x before in this project`
+        : 'before in this project';
+    // 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 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 body;
+    if (state === 'confirmed' && verified > 0) {
+        body =
+            `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') {
+        body =
+            `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') {
+        body =
+            `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') {
+        body =
+            `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 {
+        body = `This error has been seen ${seen}. No fix has been confirmed for it yet.`;
+    }
+    return `\n## Seen before\n${body}`;
+}

package/dist/tools/debugError.js

@@ -3,6 +3,7 @@ import { callDebugBackend } from '../backend.js';
 import { mapBackendErrorToToolResult } from '../errors.js';
 import { resolveAuth } from './authGate.js';
 import { getProjectId, getProjectRoot } from '../project.js';
+import { memorySection } from '../memorySection.js';
 import { resolveSourceContext } from '../sourceContext.js';
 // Tri-state verification labeling (docs/plan-v2-contract-phase1.md §1).
 // The null case is rendered ON PURPOSE: a confidence number nothing checked
@@ -121,58 +122,12 @@ export function registerDebugError(server, config) {
             // Memory first, above the badges: "this project has hit this exact
             // error before, and a fix was confirmed" is the one thing here the
             // agent cannot derive from the code in front of it, so it should not
-            // be buried in a metadata footer.
-            if (result.memory_hit) {
-                const seen = typeof result.memory_times_seen === 'number'
-                    ? `${result.memory_times_seen}x before in this project`
-                    : 'before in this project';
-                // 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}`);
+            // be buried in a metadata footer. The wording lives in
+            // ../memorySection.ts, byte-identical with the bundled server, because
+            // inlined here it drifted out of that copy entirely.
+            const memory = memorySection(result);
+            if (memory) {
+                sections.push(memory);
             }
             const badges = [];
             // Named, not counted. "Read 2 files" is unverifiable; "read src/api.ts,

package/dist/tools/reportOutcome.js

@@ -41,7 +41,7 @@ import { resolveAuth } from './authGate.js';
 export function registerReportOutcome(server, config) {
     server.registerTool('report_outcome', {
         title: 'Report Fix Outcome',
-        description: 'Report what happened after DebugAI answered — including when you did not use its fix. ' +
+        description: 'Report what happened after DebugAI answered, including when you did not use its fix. ' +
             'Call this ONCE per debug_error response, passing the debug_log_id from it. ' +
             'If you solved the problem another way, say so with result "unused" and put the real ' +
             'fix in actualFix: a case DebugAI got wrong is worth more to it than one it got right. ' +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@debugai/mcp",
-  "version": "2.4.1",
+  "version": "2.4.3",
   "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",