breakpoint-mcp 1.78.3 → 1.79.0

package/dist/csdap.js

@@ -1,16 +1,32 @@
 import { EventEmitter } from "node:events";
-import { DapError } from "./dap.js";
+import { DapError, INITIALIZED_WAIT_CEILING_MS } from "./dap.js";
 import { OverdueLedger } from "./late-reply.js";
 import { closeDetail, closeRemedy } from "./close-cause.js";
+import { timeoutRemedy } from "./timeout-cause.js";
 /**
  * Who answers this plane, in the words its late-reply ledger already uses.
  *
- * 🔴 ONE CONSTANT, TWO READERS (264). The ledger names this peer when a reply arrives
- * late and `closeRemedy` names it when the connection drops. Two literals would let the
- * same peer acquire two names on the same run, which is the class of drift 257's
- * per-instance deadline noun was written to stop.
+ * 🔴 ONE CONSTANT, THREE READERS (264, 267). The ledger names this peer when a reply
+ * arrives late, `closeRemedy` names it when the connection drops, and `timeoutRemedy`
+ * names it when a deadline fires. Two literals would let the same peer acquire two names
+ * on the same run, which is the class of drift 257's per-instance deadline noun was
+ * written to stop.
  */
 const CSDAP_PEER = "the debug adapter";
+/** The environment variable this plane's deadline comes from — see `dap.ts`'s twin. */
+const CSDAP_TIMEOUT_KNOB = "GODOT_CSDAP_TIMEOUT_MS";
+/**
+ * The next action when the adapter refuses to start a session.
+ *
+ * 🔴 THE LAST OF 264's SEVENTEEN, and the one that most looked like it already had an
+ * answer. The message names the mode and the arguments, which is a description of what
+ * was asked, not of what to do next — measured against a real netcoredbg, the two live
+ * causes are a `program` that is not a built assembly and a project that has not been
+ * compiled, and neither is visible in the argument dump the message already prints.
+ */
+export const CS_START_REMEDY = "Check that the program names a built .NET assembly and that the project compiles — the C# debug adapter refused the session, so nothing is under the debugger and no process was left running.";
+/** The next action when `cs_dbg_restart` is called with no launch behind it. */
+export const CS_RESTART_REMEDY = "Call `cs_dbg_launch` or `cs_dbg_attach` first — a restart reuses the parameters of a launch that already happened, and none has.";
 /**
  * How long `start()` waits for the entry `stopped` event when `stopAtEntry` was
  * requested. Bounded so an adapter that ignores stop-on-entry reports `running`
@@ -51,7 +67,7 @@ export class CsDapClient extends EventEmitter {
      * dropped. `seq` is monotonic and is never reset, so a seq is never reused and
      * a late response can only be its own request's.
      */
-    ledger = new OverdueLedger("C# DAP", CSDAP_PEER, "GODOT_CSDAP_TIMEOUT_MS");
+    ledger = new OverdueLedger("C# DAP", CSDAP_PEER, CSDAP_TIMEOUT_KNOB);
     configured = false;
     /** Persistent watch expressions, re-evaluated at each stop (see evaluateWatches). */
     watches = [];
@@ -128,15 +144,12 @@ export class CsDapClient extends EventEmitter {
             this.configured = false;
             this.sessionStarted = false;
             const detail = closeDetail(cause);
-            // 🔴 THE SAME ERRNO SPLIT `bridge.ts` GOT (264 §3), IN THE MESSAGE BECAUSE THIS CLASS
-            // HAS NOWHERE ELSE TO PUT IT. `DapError` carries no `remedy` field, and the plane's
-            // `fail()` renders no `remedyClause`, so the next action goes where the caller will
-            // actually read it. 264's census records the asymmetry rather than hiding it: of 25
-            // host-raised failures about the world, 13 are on classes that cannot carry an answer.
+            // 🔴 ON THE FIELD, NOT IN THE MESSAGE (267) — see `dap.ts`'s twin for the whole
+            // argument. What a caller receives is byte-identical; the channel is what changed.
             const remedy = closeRemedy(cause, CSDAP_PEER);
             for (const [, p] of this.pending) {
                 clearTimeout(p.timer);
-                p.reject(new DapError(p.command, `C# DAP connection closed${detail}${remedy ? ` — ${remedy}` : ""}`));
+                p.reject(new DapError(p.command, `C# DAP connection closed${detail}`, remedy));
             }
             this.pending.clear();
             this.emit("closed");
@@ -217,7 +230,9 @@ export class CsDapClient extends EventEmitter {
                 // Remember the seq BEFORE rejecting, so a response already in flight is
                 // reconciled rather than dropped as anonymous.
                 this.ledger.note(seq, command, timeoutMs);
-                reject(new DapError(command, `C# DAP '${command}' timed out after ${timeoutMs}ms`));
+                // The `timed out after <n>ms` wording is load-bearing — `tools/csdap.ts`'s
+                // `isDapTimeout` branches on it. The next action rides beside it, not inside it.
+                reject(new DapError(command, `C# DAP '${command}' timed out after ${timeoutMs}ms`, timeoutRemedy(CSDAP_PEER, CSDAP_TIMEOUT_KNOB)));
             }, timeoutMs);
             this.pending.set(seq, { command, resolve: resolve, reject, timer });
             this.channel.send({ seq, type: "request", command, arguments: args }).catch((err) => {
@@ -227,15 +242,23 @@ export class CsDapClient extends EventEmitter {
             });
         });
     }
+    /**
+     * Wait for `name`, bounded — resolving **`true` when the event arrived and `false` when
+     * the timer fired**. The twin of `dap.ts`'s, changed for the same measured reason (267):
+     * a `Promise<void>` made a five-second silence and a prompt event the same observable,
+     * so `start()` sent `setBreakpoints` ahead of the event that licenses it and said
+     * nothing. Driven against a stub adapter that never emits `initialized`, `start()`
+     * returned after 5,003 ms having sent the handshake in the conformant order.
+     */
     waitEvent(name, timeoutMs) {
         return new Promise((resolve) => {
             const timer = setTimeout(() => {
                 this.removeListener(name, onEvent);
-                resolve();
+                resolve(false);
             }, timeoutMs);
             const onEvent = () => {
                 clearTimeout(timer);
-                resolve();
+                resolve(true);
             };
             this.once(name, onEvent);
         });
@@ -332,7 +355,8 @@ export class CsDapClient extends EventEmitter {
         this.lastStartArgs = args;
         this.sessionStarted = false;
         // Listen for `initialized` before we ask, so we cannot miss it.
-        const onInit = this.waitEvent("initialized", Math.min(this.timeoutMs, 5000));
+        const initializedWaitMs = Math.min(this.timeoutMs, INITIALIZED_WAIT_CEILING_MS);
+        const onInit = this.waitEvent("initialized", initializedWaitMs);
         this.capabilities = await this.request("initialize", {
             clientID: "breakpoint-mcp",
             clientName: "Godot Breakpoint MCP",
@@ -364,7 +388,8 @@ export class CsDapClient extends EventEmitter {
             // EventEmitter and throws when unlistened. This one is safe to ignore.
             this.emit("start_failed", err);
         });
-        await onInit;
+        // 🔴 CAPTURED, NOT DISCARDED (267) — see `dap.ts`'s twin.
+        const initializedSeen = await onInit;
         await this.applyAllBreakpoints();
         // Arm the entry-stop wait BEFORE configurationDone is sent: netcoredbg can emit
         // `stopped` before its configurationDone response lands, and a listener attached
@@ -389,9 +414,13 @@ export class CsDapClient extends EventEmitter {
             this.state = "terminated";
             void startReq;
             const detail = fatal?.message ?? String(fatal);
+            // 🔴 THE NEXT ACTION MOVED OUT OF THE MESSAGE (267). It read *check that the program
+            // exists and is a .NET assembly* mid-sentence, between a state report and an
+            // argument dump — 264's census counted exactly this shape among the SEVEN that
+            // named an action nothing structural could read. The message now reports state; the
+            // field carries the instruction, and check 28's grammar reader can see it.
             throw new DapError(mode, `the C# debug adapter did not start the session: ${detail}. No debug session is ` +
-                `running — check that the program exists and is a .NET assembly (${mode} args: ` +
-                `${JSON.stringify(args).slice(0, 200)}).`);
+                `running (${mode} args: ${JSON.stringify(args).slice(0, 200)}).`, CS_START_REMEDY);
         }
         this.configured = true;
         this.sessionStarted = true;
@@ -411,6 +440,7 @@ export class CsDapClient extends EventEmitter {
         // simply reports `running`, as before.
         if (entryStop)
             await entryStop;
+        return { initializedSeen, initializedWaitMs };
     }
     threadId() {
         return this.lastStoppedThreadId ?? 1;
@@ -482,7 +512,7 @@ export class CsDapClient extends EventEmitter {
      */
     async restart(overrideArgs = {}, waitMs = 15000) {
         if (!this.lastStartMode || !this.lastStartArgs) {
-            throw new DapError("restart", "no C# debug session to restart — call cs_dbg_launch or cs_dbg_attach first");
+            throw new DapError("restart", "no C# debug session to restart", CS_RESTART_REMEDY);
         }
         const args = { ...this.lastStartArgs, ...overrideArgs };
         if (this.capabilities?.["supportsRestartRequest"] === true) {

package/dist/cslsp.js

@@ -2,6 +2,7 @@ import { fileURLToPath } from "node:url";
 import { LspError } from "./lsp.js";
 import { OverdueLedger } from "./late-reply.js";
 import { closeDetail, closeRemedy } from "./close-cause.js";
+import { timeoutRemedy } from "./timeout-cause.js";
 import { packageVersion } from "./version.js";
 /**
  * Who answers this plane, in the words its late-reply ledger already uses.
@@ -12,6 +13,8 @@ import { packageVersion } from "./version.js";
  * per-instance deadline noun was written to stop.
  */
 const CSLSP_PEER = "the language server";
+/** The environment variable this plane's deadline comes from — see `dap.ts`'s twin. */
+const CSLSP_TIMEOUT_KNOB = "GODOT_CSLSP_TIMEOUT_MS";
 /**
  * Minimal LSP client for the C#/.NET semantic plane (D4 C2). Transport-agnostic:
  * it drives any `JsonRpcChannel`, so production spawns OmniSharp over stdio
@@ -41,7 +44,7 @@ export class CsLspClient {
      * dropped. `nextId` is monotonic and is deliberately NOT reset by onClose(),
      * so an id is never reused and a late reply can only be its own request's.
      */
-    ledger = new OverdueLedger("C# LSP", CSLSP_PEER, "GODOT_CSLSP_TIMEOUT_MS");
+    ledger = new OverdueLedger("C# LSP", CSLSP_PEER, CSLSP_TIMEOUT_KNOB);
     /** Absolute project root path (no trailing slash), used to canonicalize URIs. */
     rootFsPath;
     constructor(channel, rootUri, timeoutMs) {
@@ -139,15 +142,17 @@ export class CsLspClient {
     }
     onClose(cause) {
         const detail = closeDetail(cause);
-        // 🔴 THE SAME ERRNO SPLIT `bridge.ts` GOT (264 §3), IN THE MESSAGE BECAUSE THIS CLASS
-        // HAS NOWHERE ELSE TO PUT IT. `LspError` carries no `remedy` field, and the plane's
-        // `fail()` renders no `remedyClause`, so the next action goes where the caller will
-        // actually read it. 264's census records the asymmetry rather than hiding it: of 25
-        // host-raised failures about the world, 13 are on classes that cannot carry an answer.
+        // 🔴 THE SAME ERRNO SPLIT `bridge.ts` GOT (264 §3), ON THE FIELD RATHER THAN IN THE
+        // MESSAGE (267). The comment that stood here said `LspError` "carries no `remedy`
+        // field, and the plane's `fail()` renders no `remedyClause`" — true when written, and
+        // the reason 264's census counted this site among the SEVEN that named an action
+        // nothing structural could read. Both halves are gone. **What a caller receives is
+        // byte-identical** and is asserted so: the message ended in ` — ${remedy}` and the
+        // renderer appends exactly that. A change of channel, not of wording.
         const remedy = closeRemedy(cause, CSLSP_PEER);
         for (const [, p] of this.pending) {
             clearTimeout(p.timer);
-            p.reject(new LspError("closed", `C# LSP connection closed${detail}${remedy ? ` — ${remedy}` : ""}`));
+            p.reject(new LspError("closed", `C# LSP connection closed${detail}`, remedy));
         }
         this.pending.clear();
         this.initialized = null;
@@ -169,7 +174,7 @@ export class CsLspClient {
                 // Remember the id BEFORE rejecting, so a reply already in flight is
                 // reconciled rather than dropped as anonymous.
                 this.ledger.note(id, method, timeoutMs);
-                reject(new LspError("timeout", `C# LSP '${method}' timed out after ${timeoutMs}ms`));
+                reject(new LspError("timeout", `C# LSP '${method}' timed out after ${timeoutMs}ms`, timeoutRemedy(CSLSP_PEER, CSLSP_TIMEOUT_KNOB)));
             }, timeoutMs);
             this.pending.set(id, { resolve: resolve, reject, timer });
             this.channel.send({ jsonrpc: "2.0", id, method, params }).catch((err) => {

package/dist/dap.js

@@ -2,23 +2,82 @@ import { EventEmitter } from "node:events";
 import { FramedConnection } from "./framing.js";
 import { OverdueLedger } from "./late-reply.js";
 import { closeDetail, closeRemedy } from "./close-cause.js";
+import { timeoutRemedy } from "./timeout-cause.js";
 /**
  * Who answers this plane, in the words its late-reply ledger already uses.
  *
- * 🔴 ONE CONSTANT, TWO READERS (264). The ledger names this peer when a reply arrives
- * late and `closeRemedy` names it when the connection drops. Two literals would let the
- * same peer acquire two names on the same run, which is the class of drift 257's
- * per-instance deadline noun was written to stop.
+ * 🔴 ONE CONSTANT, THREE READERS (264, 267). The ledger names this peer when a reply
+ * arrives late, `closeRemedy` names it when the connection drops, and `timeoutRemedy`
+ * names it when a deadline fires. Two literals would let the same peer acquire two names
+ * on the same run, which is the class of drift 257's per-instance deadline noun was
+ * written to stop.
  */
 const DAP_PEER = "the debug adapter";
+/**
+ * The environment variable this plane's deadline comes from.
+ *
+ * 🔴 ONE CONSTANT, TWO READERS, FOR THE REASON DIRECTLY ABOVE. The ledger prints it on a
+ * late reply and `timeoutRemedy` tells the caller to raise it; a knob renamed in
+ * `config.ts` and updated in one of the two would send an operator to export a variable
+ * nothing reads, which is worse than saying nothing.
+ */
+const DAP_TIMEOUT_KNOB = "GODOT_DAP_TIMEOUT_MS";
 export class DapError extends Error {
     command;
-    constructor(command, message) {
+    /**
+     * The next action — the same field `BridgeError` has carried since 254, for the same
+     * reason, and 🔴 **ITS ABSENCE WAS THE WHOLE OF THE ROW THIS CLOSES.** 264's census
+     * found 13 of 25 host-raised failures sitting on classes with nowhere to put an answer;
+     * this class was two of the four. Worse than nowhere: three of the raise sites below
+     * DID know the next action and pasted it into the MESSAGE, where nothing structural can
+     * read it — no gate can join it, `fail()` cannot render it under one clause with the
+     * rest, and a reword drops it with no test able to tell.
+     *
+     * Optional by construction, exactly as on `BridgeError`: a rejection RELAYING the
+     * adapter's own words has no business inventing a next action on its behalf. Absent
+     * here means nobody has answered that site yet, not that it is unanswerable.
+     */
+    remedy;
+    constructor(command, message, remedy) {
         super(message);
         this.command = command;
         this.name = "DapError";
+        if (remedy)
+            this.remedy = remedy;
     }
 }
+/**
+ * The ceiling on the wait for `initialized`, shared by both DAP planes.
+ *
+ * Not a new number — both clients have used `Math.min(timeoutMs, 5000)` since their
+ * handshakes were written. It is named here because 267 made the OUTCOME of that wait
+ * something a caller reads, and a window reported in a warning has to be the window that
+ * was actually waited.
+ */
+export const INITIALIZED_WAIT_CEILING_MS = 5000;
+/**
+ * What a launch/attach result says when the adapter never announced itself.
+ *
+ * 🔴 REPORTED, NOT REFUSED, AND THE CHOICE IS THE WHOLE OF THE ROW. The wait has resolved
+ * on its own timer since the handshake was written, so every adapter in the field has
+ * been launching through this path; refusing outright would break working setups to fix a
+ * silence. The shape is the one this tool already ships for `stop_on_entry_honored`: name
+ * what did not happen, name the symptom to expect, leave the session alone. A stricter
+ * refusal remains available and is a separate decision.
+ */
+export function unorderedHandshakeWarning(waitedMs) {
+    return (`The debug adapter did not announce itself with an initialized event within ${waitedMs}ms. ` +
+        `Breakpoints were applied outside the order the DAP specification requires, so a breakpoint ` +
+        `that silently fails to bind is the symptom to expect; the session is otherwise live.`);
+}
+/**
+ * The next action when `restart` is called with no launch behind it.
+ *
+ * A `*_REMEDY` const rather than a literal at the throw site because check 28's grammar
+ * reader finds host-side remedies by that naming convention — a sentence spelled inline
+ * is a sentence no gate reads, which is the defect this whole change is about.
+ */
+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
@@ -83,7 +142,7 @@ export class DapClient extends EventEmitter {
      * dropped. `seq` is monotonic and is never reset, so a seq is never reused and
      * a late response can only be its own request's.
      */
-    ledger = new OverdueLedger("DAP", DAP_PEER, "GODOT_DAP_TIMEOUT_MS");
+    ledger = new OverdueLedger("DAP", DAP_PEER, DAP_TIMEOUT_KNOB);
     configured = false;
     /** Persistent watch expressions, re-evaluated at each stop (see evaluateWatches). */
     watches = [];
@@ -152,15 +211,19 @@ export class DapClient extends EventEmitter {
             // Without it every pending request reported a generic close and the operator
             // could not tell a crashed server from something else holding the port.
             const detail = closeDetail(cause);
-            // 🔴 THE SAME ERRNO SPLIT `bridge.ts` GOT (264 §3), IN THE MESSAGE BECAUSE THIS CLASS
-            // HAS NOWHERE ELSE TO PUT IT. `DapError` carries no `remedy` field, and the plane's
-            // `fail()` renders no `remedyClause`, so the next action goes where the caller will
-            // actually read it. 264's census records the asymmetry rather than hiding it: of 25
-            // host-raised failures about the world, 13 are on classes that cannot carry an answer.
+            // 🔴 THE SAME ERRNO SPLIT `bridge.ts` GOT (264 §3), NOW ON THE FIELD RATHER THAN IN
+            // THE MESSAGE (267). The comment that stood here said `DapError` "carries no
+            // `remedy` field, and the plane's `fail()` renders no `remedyClause`, so the next
+            // action goes where the caller will actually read it" — true when it was written,
+            // and the reason 264's census counted this site among the SEVEN that named an
+            // action nothing structural could read. Both halves are gone: the field exists and
+            // `fail()` appends the clause. **What a caller receives is byte-identical**, which
+            // is asserted rather than assumed — the message ended in ` — ${remedy}` and the
+            // renderer appends exactly that, so this is a change of channel, not of wording.
             const remedy = closeRemedy(cause, DAP_PEER);
             for (const [, p] of this.pending) {
                 clearTimeout(p.timer);
-                p.reject(new DapError(p.command, `DAP connection closed${detail}${remedy ? ` — ${remedy}` : ""}`));
+                p.reject(new DapError(p.command, `DAP connection closed${detail}`, remedy));
             }
             this.pending.clear();
             this.emit("closed");
@@ -234,7 +297,10 @@ export class DapClient extends EventEmitter {
                 // Remember the seq BEFORE rejecting, so a response already in flight is
                 // reconciled rather than dropped as anonymous.
                 this.ledger.note(seq, command, timeoutMs);
-                reject(new DapError(command, `DAP '${command}' timed out after ${timeoutMs}ms`));
+                // The message keeps its exact `timed out after <n>ms` wording — `tools/dap.ts`'s
+                // `isDapTimeout` branches on it and `timeout-caveat.ts` says out loud that this
+                // predicate must not be disturbed. The next action rides beside it, not inside it.
+                reject(new DapError(command, `DAP '${command}' timed out after ${timeoutMs}ms`, timeoutRemedy(DAP_PEER, DAP_TIMEOUT_KNOB)));
             }, timeoutMs);
             this.pending.set(seq, { command, resolve: resolve, reject, timer });
             this.conn.send({ seq, type: "request", command, arguments: args }).catch((err) => {
@@ -251,15 +317,32 @@ export class DapClient extends EventEmitter {
     recentLateReplies() {
         return this.ledger.recent();
     }
+    /**
+     * Wait for `name`, bounded — resolving **`true` when the event arrived and `false` when
+     * the timer fired**.
+     *
+     * 🔴 THE RETURN VALUE IS THE FIX (267), AND THE OLD SIGNATURE IS WHY THE DEFECT COULD
+     * NOT BE SEEN. `Promise<void>` gave both outcomes the same shape, so `await onInit` in
+     * `start()` below could not distinguish *the adapter said it was ready* from *five
+     * seconds passed*, and the handshake carried on either way — sending `setBreakpoints`
+     * ahead of the event the DAP specification says must precede it, and telling nobody.
+     * Driven against a stub adapter that answers `initialize` and never emits
+     * `initialized`, `start()` returned after 5,003 ms having sent
+     * `initialize -> launch -> setBreakpoints -> configurationDone` in exactly the order a
+     * conformant run sends them, with no complaint anywhere.
+     *
+     * 262's rule, one instance further in: a guard that asks whether the container exists
+     * has not asked whether the content is there. A resolve is not an answer.
+     */
     waitEvent(name, timeoutMs) {
         return new Promise((resolve) => {
             const timer = setTimeout(() => {
                 this.removeListener(name, onEvent);
-                resolve();
+                resolve(false);
             }, timeoutMs);
             const onEvent = () => {
                 clearTimeout(timer);
-                resolve();
+                resolve(true);
             };
             this.once(name, onEvent);
         });
@@ -398,6 +481,13 @@ export class DapClient extends EventEmitter {
      * before returning — see `dbg_launch`'s `stop_on_entry`. Godot 4.7 does not honour
      * `stopOnEntry` at all, so this wait times out there and the caller is told so
      * rather than being handed a bare `running` that reads like it worked.
+     *
+     * 🆕 `initializedSeen` (267) is the SAME DISCIPLINE applied to the wait one line up.
+     * The `initialized` wait had been resolving on its own timer since this handshake was
+     * written, so a five-second silence and a prompt event were the same observable and the
+     * caller was handed a session that read exactly like a conformant one. It is reported,
+     * not refused: every adapter that works today keeps working, and the four launch tools
+     * say which of the two happened — the shape `stop_on_entry_honored` already ships in.
      */
     async start(mode, args, entryStopWaitMs = 0) {
         // Remember how we started so restart() can reuse (or override) these params.
@@ -408,7 +498,12 @@ export class DapClient extends EventEmitter {
         // restart may reach a different build than the one that dropped last time.
         this.droppedModifiers.clear();
         // Listen for `initialized` before we ask, so we cannot miss it.
-        const onInit = this.waitEvent("initialized", Math.min(this.timeoutMs, 5000));
+        // The window is captured rather than recomputed at the report site: it is
+        // `min(timeoutMs, 5000)`, so a caller who raised the deadline gets 5000 and one who
+        // lowered it gets their own number, and a warning naming the wrong one is a warning
+        // that sends an operator to the wrong knob.
+        const initializedWaitMs = Math.min(this.timeoutMs, INITIALIZED_WAIT_CEILING_MS);
+        const onInit = this.waitEvent("initialized", initializedWaitMs);
         this.capabilities = await this.request("initialize", {
             clientID: "breakpoint-mcp",
             clientName: "Godot Breakpoint MCP",
@@ -436,7 +531,11 @@ export class DapClient extends EventEmitter {
         });
         // An entry stop can arrive before configurationDone answers — arm first.
         const entryStop = entryStopWaitMs > 0 ? this.waitEvent("stopped", entryStopWaitMs) : null;
-        await onInit;
+        // 🔴 CAPTURED, NOT DISCARDED (267). `await onInit` threw this away for as long as the
+        // handshake has existed, which is why `setBreakpoints` going out ahead of the event
+        // that licenses it was invisible: the failing case and the succeeding case returned
+        // the same `undefined`.
+        const initializedSeen = await onInit;
         await this.applyAllBreakpoints();
         await this.request("configurationDone", {}).catch(() => undefined);
         // 🔴 By the time we get here an already-arrived rejection has ALREADY run its
@@ -460,7 +559,7 @@ export class DapClient extends EventEmitter {
             if (startFailure)
                 throw startFailure;
         }
-        return { entryStopSeen: this.stoppedNow() };
+        return { entryStopSeen: this.stoppedNow(), initializedSeen, initializedWaitMs };
     }
     threadId() {
         return this.lastStoppedThreadId ?? 1;
@@ -532,7 +631,7 @@ export class DapClient extends EventEmitter {
      */
     async restart(overrideArgs = {}, waitMs = 15000) {
         if (!this.lastStartMode || !this.lastStartArgs) {
-            throw new DapError("restart", "no debug session to restart — call dbg_launch or dbg_attach first");
+            throw new DapError("restart", "no debug session to restart", DAP_RESTART_REMEDY);
         }
         const args = { ...this.lastStartArgs, ...overrideArgs };
         const scene = typeof args["scene"] === "string" ? args["scene"] : null;

package/dist/exit-cause.js

@@ -42,10 +42,12 @@
  * question", spelled here as a parameter nobody declared. `exitSignal` is captured now
  * and `describeExit` says `killed by SIGKILL` where the sentence used to print a null.
  *
- * 🔵 WHAT THIS DELIBERATELY DOES NOT DO. `godot_process_output` still answers
- * `exit_code: null` for a signal-killed child and carries no `signal` key: that is a wire
- * addition to a shipped tool, it would make this cut a MINOR, and it is enqueued rather
- * than folded in. The capture is internal; only the two peer sentences read it today.
+ * 🟢 AND THE WIRE CAUGHT UP AT 267. 266 left this capture deliberately internal —
+ * `godot_output` answered `exit_code: null` for a signal-killed child with no `signal`
+ * key, because that is a wire addition to a shipped tool and would make a PATCH a MINOR.
+ * It was enqueued as `process-output-omits-signal` and paid in the next cut: the tool now
+ * answers `signal`, nullable beside `exit_code`, so a caller can tell a child that chose
+ * to exit from one the OS killed without parsing a sentence.
  */
 /** How a managed child ended, in the words a person would use. */
 export function describeExit(code, signal) {
@@ -84,9 +86,13 @@ export function readinessRemedy(causes) {
     const exited = causes.some((c) => c === "exited");
     const silent = causes.some((c) => c === "silent");
     if (exited && silent) {
-        return (`Read the output quoted above for the peer(s) that exited and fix what stopped them, ` +
-            `then check the Breakpoint MCP plugin is enabled for the one(s) that stayed up and never ` +
-            `answered — two different things failed here and only the second is about the addon.`);
+        return (
+        // Trimmed at 267 to the ceiling check 28 has always enforced on the addon's own
+        // remedies and now enforces here: it was 255 characters, and the two populations it
+        // addresses are still both named.
+        `Read the output quoted above and fix what stopped the peer(s) that exited, then check ` +
+            `the "Breakpoint MCP" plugin for the one(s) that never answered — two things failed and ` +
+            `only the second is the addon.`);
     }
     if (exited) {
         return (`Read the output quoted above and fix what stopped the child — it exited on its own, ` +

package/dist/index.js

@@ -52,7 +52,7 @@ 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.78.3" }, { capabilities: { ...TASK_CAPABILITIES, ...RESOURCE_CAPABILITIES }, taskStore });
+    const server = new McpServer({ name: "breakpoint-mcp", version: "1.79.0" }, { 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/lsp.js

@@ -3,6 +3,7 @@ import { FramedConnection } from "./framing.js";
 import { packageVersion } from "./version.js";
 import { OverdueLedger } from "./late-reply.js";
 import { closeDetail, closeRemedy } from "./close-cause.js";
+import { timeoutRemedy } from "./timeout-cause.js";
 /**
  * Who answers this plane, in the words its late-reply ledger already uses.
  *
@@ -12,12 +13,28 @@ import { closeDetail, closeRemedy } from "./close-cause.js";
  * per-instance deadline noun was written to stop.
  */
 const LSP_PEER = "the language server";
+/** The environment variable this plane's deadline comes from — see `dap.ts`'s twin. */
+const LSP_TIMEOUT_KNOB = "GODOT_LSP_TIMEOUT_MS";
 export class LspError extends Error {
     code;
-    constructor(code, message) {
+    /**
+     * The next action — the same field `BridgeError` has carried since 254, added here at
+     * 267 for the same reason it was added there. 🔴 **ITS ABSENCE WAS THE ROW.** 264's
+     * census found 13 of 25 host-raised failures sitting on classes with nowhere to put an
+     * answer, and this class was two of the four. The close handler below already KNEW the
+     * next action and pasted it into the message, where no gate can join it and `fail()`
+     * cannot render it under one clause.
+     *
+     * Optional by construction, as on `BridgeError`: a rejection relaying the language
+     * server's own words has no business inventing an action on its behalf.
+     */
+    remedy;
+    constructor(code, message, remedy) {
         super(message);
         this.name = "LspError";
         this.code = code;
+        if (remedy)
+            this.remedy = remedy;
     }
 }
 /**
@@ -41,7 +58,7 @@ export class LspClient {
      * dropped. `nextId` is monotonic and is deliberately NOT reset by onClose(),
      * so an id is never reused and a late reply can only be its own request's.
      */
-    ledger = new OverdueLedger("LSP", LSP_PEER, "GODOT_LSP_TIMEOUT_MS");
+    ledger = new OverdueLedger("LSP", LSP_PEER, LSP_TIMEOUT_KNOB);
     /** Absolute project root path (no trailing slash), used to canonicalize URIs. */
     rootFsPath;
     constructor(host, port, rootUri, timeoutMs) {
@@ -143,15 +160,17 @@ export class LspClient {
         // Without it every pending request reported a generic close and the operator
         // could not tell a crashed server from something else holding the port.
         const detail = closeDetail(cause);
-        // 🔴 THE SAME ERRNO SPLIT `bridge.ts` GOT (264 §3), IN THE MESSAGE BECAUSE THIS CLASS
-        // HAS NOWHERE ELSE TO PUT IT. `LspError` carries no `remedy` field, and the plane's
-        // `fail()` renders no `remedyClause`, so the next action goes where the caller will
-        // actually read it. 264's census records the asymmetry rather than hiding it: of 25
-        // host-raised failures about the world, 13 are on classes that cannot carry an answer.
+        // 🔴 THE SAME ERRNO SPLIT `bridge.ts` GOT (264 §3), ON THE FIELD RATHER THAN IN THE
+        // MESSAGE (267). The comment that stood here said `LspError` "carries no `remedy`
+        // field, and the plane's `fail()` renders no `remedyClause`" — true when written, and
+        // the reason 264's census counted this site among the SEVEN that named an action
+        // nothing structural could read. Both halves are gone. **What a caller receives is
+        // byte-identical** and is asserted so: the message ended in ` — ${remedy}` and the
+        // renderer appends exactly that. A change of channel, not of wording.
         const remedy = closeRemedy(cause, LSP_PEER);
         for (const [, p] of this.pending) {
             clearTimeout(p.timer);
-            p.reject(new LspError("closed", `LSP connection closed${detail}${remedy ? ` — ${remedy}` : ""}`));
+            p.reject(new LspError("closed", `LSP connection closed${detail}`, remedy));
         }
         this.pending.clear();
         this.initialized = null;
@@ -166,7 +185,7 @@ export class LspClient {
                 // Remember the id BEFORE rejecting, so a reply already in flight is
                 // reconciled rather than dropped as anonymous.
                 this.ledger.note(id, method, timeoutMs);
-                reject(new LspError("timeout", `LSP '${method}' timed out after ${timeoutMs}ms`));
+                reject(new LspError("timeout", `LSP '${method}' timed out after ${timeoutMs}ms`, timeoutRemedy(LSP_PEER, LSP_TIMEOUT_KNOB)));
             }, timeoutMs);
             this.pending.set(id, { resolve: resolve, reject, timer });
             this.conn.send({ jsonrpc: "2.0", id, method, params }).catch((err) => {

package/dist/readiness.js

@@ -93,16 +93,35 @@ export async function waitForRuntimeBridge(cfg, timeoutMs) {
  * message that says what broke has done half the job — applied to a field rather
  * than to a message: `bridge_ready: false` says what happened, and this says what
  * to do about it.
+ *
+ * 🔴 BOTH SENTENCES WERE REWRITTEN AT 267, AND A GATE FOUND THEM RATHER THAN A READER.
+ * Widening check 28's grammar to the host's OWN remedies — until then it read only
+ * `error_remedies.gd` — refused both of these at once, and the two refusals were the same
+ * two defects this project has now found three times:
+ *
+ * 1. **They opened by describing the failure.** *The process launched but the runtime
+ *    bridge … did not answer ping* is a second copy of what `bridge_ready: false` already
+ *    said. The next action arrived in the last clause, after 200 characters, which is the
+ *    exact shape 254 moved the addon's remedies away from.
+ * 2. 🔴 **AND THE SECOND ASKED A QUESTION OVER TWO CAUSES.** *Is the "Breakpoint MCP"
+ *    plugin enabled in this project?* — with *if the project is simply slow to boot* three
+ *    clauses later, so the sentence named both causes and instructed on neither. That is
+ *    266 §1's finding, in a different file, surviving the session that fixed it: the
+ *    question was removed from `peers.ts` and left standing here, because nothing joined
+ *    the two sites. A gate over the whole population is what joined them.
+ *
+ * Neither cause can be discriminated from here — a ping that went unanswered inside the
+ * wait says nothing about which — so the repair is to name both and give one action each,
+ * not to guess.
  */
 export function notReadyRemedy(cfg, waitedMs) {
     if (waitedMs <= 0) {
-        return (`The process launched and no wait was requested (wait_timeout_ms 0), so nothing here knows whether the ` +
-            `runtime bridge at ${cfg.runtimeHost}:${cfg.runtimePort} is up yet. Call runtime_get_tree to find out, or ` +
-            `re-run without wait_timeout_ms and this tool will wait and answer.`);
+        return (`Call \`runtime_get_tree\` to find out whether the runtime bridge at ` +
+            `${cfg.runtimeHost}:${cfg.runtimePort} is up, or re-run with a wait above 0 — the process launched ` +
+            `and wait_timeout_ms 0 asked for no wait, so this is unknown, not failed.`);
     }
-    return (`The process launched but the runtime bridge at ${cfg.runtimeHost}:${cfg.runtimePort} did not answer ping ` +
-        `within ${waitedMs} ms, so a runtime_* call will fail until it does. Is the "Breakpoint MCP" plugin enabled in ` +
-        `this project? The runtime autoload it registers is what binds the port. If the project is simply slow to boot, ` +
-        `raise the wait with wait_timeout_ms.`);
+    return (`Raise wait_timeout_ms and retry if the project is slow to boot, and check the "Breakpoint MCP" ` +
+        `plugin is enabled if it is not — the bridge at ${cfg.runtimeHost}:${cfg.runtimePort} answered no ping ` +
+        `in ${waitedMs} ms and this host cannot tell those apart.`);
 }
 //# sourceMappingURL=readiness.js.map

package/dist/schemas.js

@@ -113,6 +113,10 @@ export const outputSchemas = {
         id: z.string(),
         exited: z.boolean(),
         exit_code: z.number().nullable(),
+        // The signal that ended the child, when one did — null otherwise, and null for a
+        // process still running. Nullable rather than optional, matching exit_code beside it:
+        // a key that vanishes cannot be told apart from a host too old to send it.
+        signal: z.string().nullable(),
         latest_seq: z.number(),
         lines: z.array(z.object({ seq: z.number(), stream: z.enum(["stdout", "stderr"]), text: z.string() })),
     },
@@ -449,6 +453,9 @@ export const outputSchemas = {
         // one inside a shape makes contract_check.py swallow every later entry into
         // this one, and the drift error then names every field in the file.
         stop_on_entry_honored: z.boolean().optional(),
+        // Whether the adapter emitted its initialized event before breakpoints were applied.
+        // Always present: false means the handshake ran out of the order DAP specifies.
+        initialized_seen: z.boolean(),
         // Modifiers dropped when the handshake applied the BUFFERED breakpoints. Buffered
         // modifiers cannot be feature-detected at set time, so this is where their fate is
         // reported; dbg_set_breakpoints said only that detection was deferred.
@@ -457,6 +464,7 @@ export const outputSchemas = {
     },
     dbg_attach: {
         session_id: z.string(), state: z.string(),
+        initialized_seen: z.boolean(),
         unsupported_modifiers: z.array(z.string()).optional(),
         warning: z.string().optional(),
     },
@@ -496,8 +504,8 @@ export const outputSchemas = {
         unresolved: z.array(z.object({ name: z.string(), reason: z.string() })),
     },
     // ---- Plane D: C# debugging / netcoredbg DAP (tools/csdap.ts) ----
-    cs_dbg_launch: { session_id: z.string(), state: z.string() },
-    cs_dbg_attach: { session_id: z.string(), state: z.string() },
+    cs_dbg_launch: { session_id: z.string(), state: z.string(), initialized_seen: z.boolean(), warning: z.string().optional() },
+    cs_dbg_attach: { session_id: z.string(), state: z.string(), initialized_seen: z.boolean(), warning: z.string().optional() },
     cs_dbg_set_breakpoints: {
         path: z.string(), buffered: z.boolean(),
         breakpoints: z.array(z.object({ line: z.number(), verified: z.boolean() })),

package/dist/timeout-cause.js

@@ -0,0 +1,48 @@
+/**
+ * The next action when a request hit its own deadline — the last class of host-raised
+ * failure on the DAP and LSP planes that had nothing to say.
+ *
+ * 🔴 WHY THIS EXISTS, AND WHY IT IS THE END OF A ROW RATHER THAN THE MIDDLE OF ONE.
+ * 264's census counted 25 host-raised failures about the world: ONE carried a remedy in
+ * a field, SEVEN named a next action inside their message where no reader counts it, and
+ * SEVENTEEN said nothing at all. 266 answered the last three that had a field to put an
+ * answer in, and left five that did not — four request deadlines and the C# session
+ * start — because `DapError` and `LspError` had no `remedy` at all. **The gap was never
+ * that nobody knew the answer; it was that there was nowhere to put it.** This module is
+ * the answer for four of the five, and the field it rides on is the other half.
+ *
+ * 🔴 WHAT THE HOST ACTUALLY KNOWS AT THE MOMENT A DEADLINE FIRES, which is the whole
+ * argument for the sentence below. A dropped connection does NOT reach here: every one of
+ * the four clients rejects its pending map from the close handler, with `closeDetail` and
+ * `closeRemedy` (264), on a different code path. An unreachable peer does not reach here
+ * either — `connect()` fails earlier and differently. By the time a deadline can fire the
+ * connection was established and the frame was written, so the honest reading is *the
+ * peer has this request and has not answered yet*, not *the request did not go through*.
+ * That is `timeout-caveat.ts`'s measured argument for the editor bridge, made one
+ * transport over, where it holds for the same structural reason.
+ *
+ * 🔴 AND WHAT IT DELIBERATELY DOES NOT SAY. It does not tell the caller to retry. Three
+ * of the four planes carry mutating requests (`setVariable`, `textDocument/rename`,
+ * `evaluate` with a side effect), and the ledger in `late-reply.ts` exists because a
+ * reply arriving after its deadline is ordinary here, not exotic — so an unqualified
+ * *try again* is the instruction that duplicates the write. The sentence names the knob
+ * and says plainly that a retry is a second request. 264's rule: measure N families,
+ * speak for N.
+ */
+/**
+ * The next action for a request that outlived its deadline.
+ *
+ * `peer` is the noun the plane's own late-reply ledger already uses — "the debug
+ * adapter", "the language server", "the C# debug adapter", "the C# language server" —
+ * so the sentence names what the caller was talking to rather than a socket, exactly as
+ * `closeRemedy` does. `knob` is the environment variable `config.ts` reads that
+ * deadline from, so the instruction is executable rather than a suggestion to be patient.
+ *
+ * Written to the grammar check 28 enforces on `error_remedies.gd`: one imperative at the
+ * head, a full stop at the end, and nothing named that does not resolve.
+ */
+export function timeoutRemedy(peer, knob) {
+    return (`Raise \`${knob}\` if ${peer} is merely slow — the request reached it and this ` +
+        `host's deadline fired first, so it may still answer and a retry sends a second request.`);
+}
+//# sourceMappingURL=timeout-cause.js.map

package/dist/tools/csdap.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { DapError } from "../dap.js";
+import { DapError, unorderedHandshakeWarning } from "../dap.js";
+import { remedyClause } from "../bridge.js";
 import { resolveSourceFile } from "../paths.js";
 import { gate } from "../confirm.js";
 import { ok } from "./lsp-common.js";
@@ -32,15 +33,28 @@ function fail(err) {
             content: [{
                     type: "text",
                     text: `C# DAP error [${command}]: the debug adapter reported a failure with no message. ` +
-                        `The request was rejected; nothing was changed by it.`,
+                        `The request was rejected; nothing was changed by it.${remedyClause(err)}`,
                 }],
         };
     }
     return {
         isError: true,
-        content: [{ type: "text", text: `C# DAP error [${command}]: ${message}` }],
+        content: [{ type: "text", text: `C# DAP error [${command}]: ${message}${remedyClause(err)}` }],
     };
 }
+/**
+ * Record whether the adapter announced itself before its breakpoints were applied — the
+ * twin of `tools/dap.ts`'s, for the same measured reason (267). Kept per-plane rather than
+ * shared because the two planes' result objects are built by different code and a helper
+ * imported across them would be the only thing they share.
+ */
+function reportHandshakeOrder(result, seen, waitedMs) {
+    result.initialized_seen = seen;
+    if (seen)
+        return;
+    const note = unorderedHandshakeWarning(waitedMs);
+    result.warning = typeof result.warning === "string" && result.warning.length > 0 ? `${result.warning} ${note}` : note;
+}
 /** Throw a host refusal — rendered verbatim by `fail()`, never as an adapter error. */
 function refuse(message, code) {
     throw Object.assign(new Error(message), { refusal: true, code });
@@ -239,14 +253,16 @@ export function registerCsDapTools(server, dap, cfg) {
             };
         }
         try {
-            await dap.start("launch", {
+            const { initializedSeen, initializedWaitMs } = await dap.start("launch", {
                 program: resolvedProgram,
                 args: resolvedArgs,
                 cwd: cfg.csDapProjectPath,
                 stopAtEntry: stop_on_entry ?? false,
                 justMyCode: just_my_code ?? true,
             });
-            return ok({ session_id: "csharp", state: dap.state });
+            const result = { session_id: "csharp", state: dap.state };
+            reportHandshakeOrder(result, initializedSeen, initializedWaitMs);
+            return ok(result);
         }
         catch (err) {
             return fail(err);
@@ -280,8 +296,10 @@ export function registerCsDapTools(server, dap, cfg) {
                         `was previously reported as "running" against a process that does not exist.`, "no_such_process");
                 }
             }
-            await dap.start("attach", { processId: process_id });
-            return ok({ session_id: "csharp", state: dap.state });
+            const { initializedSeen, initializedWaitMs } = await dap.start("attach", { processId: process_id });
+            const result = { session_id: "csharp", state: dap.state };
+            reportHandshakeOrder(result, initializedSeen, initializedWaitMs);
+            return ok(result);
         }
         catch (err) {
             return fail(err);

package/dist/tools/dap.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { DapError } from "../dap.js";
+import { DapError, unorderedHandshakeWarning } from "../dap.js";
+import { remedyClause } from "../bridge.js";
 import { resolveSourceFile } from "../paths.js";
 import { gate } from "../confirm.js";
 import { ok } from "./lsp-common.js";
@@ -116,15 +117,20 @@ function fail(err) {
     // asked. Same distinction lsp-common.fail() already draws for the LSP planes.
     const e = err;
     if (err instanceof DapRefusal || e?.refusal) {
-        return { isError: true, content: [{ type: "text", text: e.message ?? String(err) }] };
+        return { isError: true, content: [{ type: "text", text: `${e.message ?? String(err)}${remedyClause(err)}` }] };
     }
     // An adapter can answer a failure with an EMPTY message (netcoredbg did, on
     // setVariable). `?? String(err)` only covers an ABSENT one, so the whole answer
     // became a label and a colon.
     const detail = e.message && e.message.trim() !== "" ? e.message : String(err);
+    // 🆕 267 — `remedyClause(err)` reads the `remedy` FIELD, which `DapError` gained this
+    // release. Before it, this plane's next actions were pasted inside the message at the
+    // raise site and this renderer had nothing to append; check 28 could not see them and a
+    // reword dropped one silently. Empty string when the site has no answer, so a rejection
+    // relaying the adapter's own words is byte-identical to what it was.
     return {
         isError: true,
-        content: [{ type: "text", text: `DAP error [${e.command ?? "error"}]: ${detail}` }],
+        content: [{ type: "text", text: `DAP error [${e.command ?? "error"}]: ${detail}${remedyClause(err)}` }],
     };
 }
 /**
@@ -144,6 +150,23 @@ function isDapTimeout(err) {
  * it, the breakpoint halted every frame, and the result carried no warning at all.
  * Detection now happens where the modifiers go on the wire, so every path gets it.
  */
+/**
+ * Record whether the adapter announced itself before its breakpoints were applied.
+ *
+ * 🔴 THE KEY IS ALWAYS PRESENT, THE WARNING ONLY WHEN IT IS FALSE (267). A field that
+ * appears only on the bad path is a field a caller cannot branch on — it cannot tell
+ * *this adapter was conformant* from *this host is too old to say* — which is the shape
+ * `required-any-reachability` is open about one layer up. The warning is the human half
+ * and merges rather than clobbers, for the same reason `reportDroppedModifiers` does:
+ * an out-of-order handshake and an unhonoured stop-on-entry can both be true at once.
+ */
+function reportHandshakeOrder(result, seen, waitedMs) {
+    result.initialized_seen = seen;
+    if (seen)
+        return;
+    const note = unorderedHandshakeWarning(waitedMs);
+    result.warning = typeof result.warning === "string" && result.warning.length > 0 ? `${result.warning} ${note}` : note;
+}
 const warnDropped = (dropped) => `The connected Godot debug adapter does not support ${dropped.join(", ")} on breakpoints (it advertises ` +
     `${dropped.length > 1 ? "them" : "it"} unsupported), so ${dropped.length > 1 ? "they were" : "it was"} dropped — ` +
     `the affected breakpoint(s) will halt unconditionally.`;
@@ -312,8 +335,9 @@ export function registerDapTools(server, dap, cfg) {
             };
         }
         try {
-            const { entryStopSeen } = await dap.start("launch", { project: cfg.projectPath, scene: scene ?? "main", stopOnEntry: stop_on_entry ?? false }, stop_on_entry ? ENTRY_STOP_WAIT_MS : 0);
+            const { entryStopSeen, initializedSeen, initializedWaitMs } = await dap.start("launch", { project: cfg.projectPath, scene: scene ?? "main", stopOnEntry: stop_on_entry ?? false }, stop_on_entry ? ENTRY_STOP_WAIT_MS : 0);
             const result = { session_id: "godot", state: dap.state, scene: scene ?? "main" };
+            reportHandshakeOrder(result, initializedSeen, initializedWaitMs);
             if (stop_on_entry) {
                 // 🔴 Measured on Godot 4.7: stopOnEntry is ignored outright — the game ran to
                 // completion and printed its _ready() line while the tool answered a bare
@@ -348,8 +372,9 @@ export function registerDapTools(server, dap, cfg) {
         },
     }, async ({ address, port }) => {
         try {
-            await dap.start("attach", { address: address ?? "127.0.0.1", port });
+            const { initializedSeen, initializedWaitMs } = await dap.start("attach", { address: address ?? "127.0.0.1", port });
             const result = { session_id: "godot", state: dap.state };
+            reportHandshakeOrder(result, initializedSeen, initializedWaitMs);
             reportDroppedModifiers(result);
             return ok(result);
         }

package/dist/tools/lsp-common.js

@@ -4,6 +4,7 @@
 // MarkupContent), so these live once here rather than being duplicated per plane.
 // The generic MCP success-envelope helper `ok()` is the single shared envelope
 // shape and is imported by the other tool modules too, not only the LSP planes.
+import { remedyClause } from "../bridge.js";
 // LSP CompletionItemKind numeric -> readable name.
 export const COMPLETION_KIND = {
     1: "text", 2: "method", 3: "function", 4: "constructor", 5: "field", 6: "variable",
@@ -57,12 +58,14 @@ export function fail(err) {
     if (e?.refusal) {
         return {
             isError: true,
-            content: [{ type: "text", text: e.message ?? String(err) }],
+            content: [{ type: "text", text: `${e.message ?? String(err)}${remedyClause(err)}` }],
         };
     }
+    // 🆕 267 — see `tools/dap.ts`. `LspError` gained a `remedy` field this release; this is
+    // the one place both LSP planes render, so both get the clause from one edit.
     return {
         isError: true,
-        content: [{ type: "text", text: `LSP error [${e.code ?? "error"}]: ${e.message ?? String(err)}` }],
+        content: [{ type: "text", text: `LSP error [${e.code ?? "error"}]: ${e.message ?? String(err)}${remedyClause(err)}` }],
     };
 }
 /**
@@ -82,7 +85,7 @@ export function failPath(err) {
     const be = err;
     return {
         isError: true,
-        content: [{ type: "text", text: `Path error [${be?.code ?? "error"}]: ${be?.message ?? String(err)}` }],
+        content: [{ type: "text", text: `Path error [${be?.code ?? "error"}]: ${be?.message ?? String(err)}${remedyClause(err)}` }],
     };
 }
 /**

package/dist/tools/processes.js

@@ -157,7 +157,12 @@ export function registerProcessTools(server, cfg) {
         const since = since_seq ?? 0;
         const want = stream ?? "both";
         const lines = m.lines.filter((l) => l.seq > since && (want === "both" || l.stream === want));
-        return ok({ id, exited: m.exited, exit_code: m.exitCode, latest_seq: m.seq, lines });
+        // 🆕 267 — `signal` on the wire. `exit_code` alone could not distinguish a child
+        // that chose to exit 0 from one the OS killed: both answered `exited: true` with a
+        // null-or-number code, and a SIGKILLed child answered `exit_code: null`, which reads
+        // exactly like a process that has not finished. The registry has captured the signal
+        // since 266; this is the key that lets a caller read it.
+        return ok({ id, exited: m.exited, exit_code: m.exitCode, signal: m.exitSignal, latest_seq: m.seq, lines });
     });
     server.registerTool("godot_stop", {
         title: "Stop managed process",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "breakpoint-mcp",
-  "version": "1.78.3",
+  "version": "1.79.0",
   "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",