breakpoint-mcp 1.82.0 → 1.82.1

package/dist/dap.js

@@ -120,9 +120,15 @@ export function unorderedHandshakeWarning(waitedMs) {
 export const DAP_RESTART_REMEDY = "Call `dbg_launch` or `dbg_attach` first — a restart reuses the parameters of a launch that already happened, and none has.";
 /**
  * Per-line breakpoint modifier fields, each gated by an adapter capability. Godot
- * advertises all three false AND ignores them — a "conditional" breakpoint halts
+ * advertises none of the three AND ignores them — a "conditional" breakpoint halts
  * unconditionally (measured live on 4.3 and 4.7), so an undropped modifier is not a
  * no-op, it is the opposite of what the caller asked for.
+ *
+ * 🔴 278 — THE KEYS ARE ABSENT, NOT `false`, AND THIS PARAGRAPH SAID `false` FOR AS LONG
+ * AS IT HAS EXISTED. Both read the same way through `!== true`, which is why nothing ever
+ * caught it; they are different facts about the adapter, and `docs/dap_capability_ledger.json`
+ * is where the difference is now recorded rather than described. The ledger carries the run
+ * the reading came from, so the next reader can check it instead of believing this comment.
  */
 export const BREAKPOINT_MODIFIER_CAPS = {
     condition: "supportsConditionalBreakpoints",

package/dist/index.js

@@ -17,6 +17,7 @@ import { applyWireDefaults } from "./wire-defaults.js";
 import { applyOutputSchemas } from "./schemas.js";
 import { applyAnnotations } from "./annotations.js";
 import { applyTimeoutCaveat } from "./timeout-caveat.js";
+import { packageVersion } from "./version.js";
 import { applyCapabilities, applyDroppedToolRefusal, droppedTools, registerCapabilitiesResource, selectPrivilegedGroups, } from "./capabilities.js";
 import { taskStore, TASK_CAPABILITIES } from "./tasks.js";
 import { RESOURCE_CAPABILITIES, registerResourceSubscriptions } from "./subscriptions.js";
@@ -52,7 +53,14 @@ async function main() {
     // so long jobs (export/import/headless script) support poll/await/cancel.
     // D3: also advertise resources.subscribe so clients can subscribe to
     // godot://… resources and receive notifications/resources/updated.
-    const server = new McpServer({ name: "breakpoint-mcp", version: "1.82.0" }, { capabilities: { ...TASK_CAPABILITIES, ...RESOURCE_CAPABILITIES }, taskStore });
+    // 🔴 READ, NEVER WRITTEN HERE (#248, twenty-eight sessions). This is the version every
+    // connected client is told at `initialize`, and it was the ONE place in host/src where
+    // a version was a literal — while `--version`, `lsp.ts`'s clientInfo and `cslsp.ts`'s
+    // all call `packageVersion()`. `version.ts` says why in its own words: the best
+    // outcome is not a gated literal but no literal at all, and the incident it documents
+    // is this exact field — twenty-odd releases announcing 0.2.0 to every language server
+    // they met, because a literal nobody compares to anything cannot go stale loudly.
+    const server = new McpServer({ name: "breakpoint-mcp", version: packageVersion() }, { capabilities: { ...TASK_CAPABILITIES, ...RESOURCE_CAPABILITIES }, taskStore });
     // 208 §7.1 — delete from the wire what the protocol already says: the SDK's
     // draft-07 `$schema` inside every input/output schema (MCP's default dialect is
     // 2020-12, and declaring another is an explicit switch a peer may reject), and

package/dist/tools/dap.js

@@ -398,17 +398,18 @@ export function registerDapTools(server, dap, cfg) {
             "or a path resolving outside the Godot project root — Godot binds breakpoints only to scripts in the project it runs, so " +
             "unlike cs_dbg_set_breakpoints an absolute path outside the root is refused here too. " +
             "Feature-detected: the per-line conditions / hit_conditions / log_messages modifiers are only sent when the connected adapter " +
-            "advertises support (supportsConditionalBreakpoints / supportsHitConditionalBreakpoints / supportsLogPoints). On an adapter that " +
-            "advertises them unsupported (Godot advertises all three false and IGNORES them, so the breakpoint would halt unconditionally) the " +
-            "modifier is dropped and the result includes `unsupported_modifiers` plus a `warning`. Detection happens when the breakpoints are " +
+            "advertises support (supportsConditionalBreakpoints / supportsHitConditionalBreakpoints / supportsLogPoints). Measured: no Godot " +
+            "build this project tests advertises it — 4.3-stable and 4.7-stable advertise none of the three (the keys are ABSENT rather than " +
+            "false) and IGNORE the modifiers, so such a breakpoint would halt unconditionally; see docs/dap_capability_ledger.json. All three " +
+            "are therefore dropped on every build measured, and the result includes `unsupported_modifiers` plus a `warning`. Detection happens when the breakpoints are " +
             "applied, so it covers buffered ones too: setting modifiers before a session exists returns `modifier_detection: \"deferred\"` with a " +
             "warning, and dbg_launch then reports the `unsupported_modifiers` actually dropped during the handshake.",
         inputSchema: {
             path: z.string().describe("Script path (res://..., absolute, or project-relative)"),
             lines: z.array(z.number().int().positive()).describe("1-based line numbers"),
-            conditions: z.array(z.string().nullable()).optional().describe("Optional per-line condition expressions (aligned to lines, use null to skip a line); break only when the expression is true"),
-            hit_conditions: z.array(z.string().nullable()).optional().describe("Optional per-line hit expressions aligned to lines, e.g. '>3' or '%5' — break based on hit count (null to skip)"),
-            log_messages: z.array(z.string().nullable()).optional().describe("Optional per-line log messages aligned to lines; a message turns that breakpoint into a LOGPOINT (logs and continues, never halts). {expr} interpolates (null to skip)."),
+            conditions: z.array(z.string().nullable()).optional().describe("Optional per-line condition expressions (aligned to lines, use null to skip a line); break only when the expression is true. Gated on supportsConditionalBreakpoints — Measured: no Godot build this project tests advertises it, so this is dropped and reported on every build measured."),
+            hit_conditions: z.array(z.string().nullable()).optional().describe("Optional per-line hit expressions aligned to lines, e.g. '>3' or '%5' — break based on hit count (null to skip). Gated on supportsHitConditionalBreakpoints — Measured: no Godot build this project tests advertises it, so this is dropped and reported on every build measured."),
+            log_messages: z.array(z.string().nullable()).optional().describe("Optional per-line log messages aligned to lines; a message turns that breakpoint into a LOGPOINT (logs and continues, never halts). {expr} interpolates (null to skip). Gated on supportsLogPoints — Measured: no Godot build this project tests advertises it, so this is dropped and reported on every build measured."),
         },
     }, async ({ path, lines, conditions, hit_conditions, log_messages }) => {
         try {
@@ -641,8 +642,11 @@ export function registerDapTools(server, dap, cfg) {
             "(DAP setExceptionBreakpoints). Pass the filter IDs to enable; call with no filters (or []) to clear them. The result echoes the " +
             "active filters and lists `available_filters` — the exception filters the connected adapter actually advertises. " +
             "Requires a running debug session. Not gated (it only configures the debugger). " +
-            "Feature-detected: on an adapter that advertises no exceptionBreakpointFilters (e.g. Godot 4.3, which also does not answer " +
-            "the request — it would otherwise time out) it returns a clear \"unsupported\" message WITHOUT sending anything.",
+            "Feature-detected: on an adapter that advertises no exceptionBreakpointFilters (which also does not answer the request — it would " +
+            "otherwise time out) it returns a clear \"unsupported\" message WITHOUT sending anything. Measured: no Godot build this project " +
+            "tests advertises it — 4.3-stable AND 4.7-stable both advertise no filters, so on a shipped engine it is unsupported surface today " +
+            "rather than a feature you can reach; see docs/dap_capability_ledger.json. This sentence used to name 4.3 alone as the example, " +
+            "which read as though a newer build had filters. None does.",
         inputSchema: {
             filters: z.array(z.string()).optional().describe("Exception filter IDs to enable (default none = clear). Choose from available_filters in the result."),
         },
@@ -782,6 +786,9 @@ export function registerDapTools(server, dap, cfg) {
             "list the valid goto targets on that line; when the line has exactly one target (or you pass `target_id`) it jumps there. " +
             "DESTRUCTIVE: skips or repeats code by moving execution — confirm with the user and keep this gated. " +
             "Feature-detected: on an adapter that does not advertise `supportsGotoTargetsRequest` it returns a clear \"unsupported\" message WITHOUT prompting. " +
+            "Measured: no Godot build this project tests advertises it — 4.3-stable and 4.7-stable both refuse this tool, so on a shipped engine it " +
+            "is unsupported surface today rather than a feature you can reach; see docs/dap_capability_ledger.json. It is kept, and kept guarded, " +
+            "because a capability is not a boundary and a build can start advertising it. " +
             "Refuses a source that can never carry a target — a missing file, a directory, an empty path (which resolves to the project root), " +
             "or a path resolving outside the Godot project root — the same guard dbg_set_breakpoints applies. " +
             "Only meaningful while stopped at a breakpoint.",
@@ -854,7 +861,9 @@ export function registerDapTools(server, dap, cfg) {
             "resolvable id is armed in one setDataBreakpoints call. Call with no `watch` (or []) to clear all data breakpoints. The result reports the " +
             "armed `breakpoints` (each with its resolved data_id and verified flag) and any `unresolved` variables the adapter cannot watch. " +
             "Requires a running session; NOT gated (it only configures the debugger). Feature-detected: on an adapter that does not advertise " +
-            "`supportsDataBreakpoints` it returns a clear \"unsupported\" message without sending any request.",
+            "`supportsDataBreakpoints` it returns a clear \"unsupported\" message without sending any request. Measured: no Godot build this " +
+            "project tests advertises it — 4.3-stable and 4.7-stable both refuse this tool, so on a shipped engine it is unsupported surface " +
+            "today rather than a feature you can reach; see docs/dap_capability_ledger.json.",
         inputSchema: {
             watch: z.array(z.object({
                 name: z.string().describe("Variable name to watch"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "breakpoint-mcp",
-  "version": "1.82.0",
+  "version": "1.82.1",
   "description": "MCP server exposing Godot to AI coding assistants over the Model Context Protocol — developed and tested with Claude — across four planes (CLI, live editor, LSP+DAP, runtime) with elicitation-gated destructive tools, long jobs on the formal MCP task model, captured console output, and MCP resources.",
   "type": "module",
   "license": "MIT",