Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(gdb): gate readiness and retain caller cancellation through cleanup
morluto696832caa3cf
diff --git a/src/gdb/GdbSessionManager.ts b/src/gdb/GdbSessionManager.tsindex dc517aadc..dcde0c90f 100644--- a/src/gdb/GdbSessionManager.ts+++ b/src/gdb/GdbSessionManager.ts@@ -43,6 +43,30 @@ const DEFAULT_MAX_SESSIONS = 8;const MAX_PENDING_GDB_COMMANDS = 16;const RECENT_RECORD_TRUNCATION_MARKER = "[recent record truncated]";+const cancelledWithCallerReason = (+ operation: string,+ signal: AbortSignal,+ previous?: AnalysisCancelledError,+): AnalysisCancelledError => {+ const cancellation = new AnalysisCancelledError(operation, {+ cause: signal.reason,+ cleanupPrimary: previous,+ ...(previous?.diagnostics === undefined+ ? {}+ : { diagnostics: previous.diagnostics }),+ ...(previous?.capturedOutput === undefined+ ? {}+ : { capturedOutput: previous.capturedOutput }),+ ...(previous?.cleanup === undefined ? {} : { cleanup: previous.cleanup }),+ ...(previous?.partialObservation === undefined+ ? {}+ : { partialObservation: previous.partialObservation }),+ });+ if (previous?.cleanupIncomplete)+ cancellation.bindCleanupDependencies([previous]);+ return cancellation;+};+export const GDB_PROVIDER_IDENTITY = {id: "gnu.gdb",name: "GNU GDB",@@ -572,7 +596,11 @@ export class GdbSessionManager {]),);if (this.#closing || signal?.aborted)- return err(new AnalysisCancelledError("start_gdb_session"));+ return err(+ signal?.aborted+ ? cancelledWithCallerReason("start_gdb_session", signal)+ : new AnalysisCancelledError("start_gdb_session"),+ );if (this.#platform !== "linux")return err(new AnalysisCapabilityUnavailableError(@@ -584,7 +612,12 @@ export class GdbSessionManager {),);const controller = new AbortController();- const relayAbort = (): void => controller.abort(signal?.reason);+ let callerAbortWon = false;+ const relayAbort = (): void => {+ if (controller.signal.aborted) return;+ callerAbortWon = true;+ controller.abort(signal?.reason);+ };signal?.addEventListener("abort", relayAbort, { once: true });if (signal?.aborted) relayAbort();const tracked = Promise.resolve()@@ -594,7 +627,20 @@ export class GdbSessionManager {this.#activeStarts.delete(controller);});this.#activeStarts.set(controller, tracked);- return tracked;+ return tracked.then((result) =>+ !result.ok &&+ result.error instanceof AnalysisCancelledError &&+ callerAbortWon &&+ signal !== undefined+ ? err(+ cancelledWithCallerReason(+ "start_gdb_session",+ signal,+ result.error,+ ),+ )+ : result,+ );}async #startWithReservation(@@ -688,7 +734,10 @@ export class GdbSessionManager {};launched = await this.#spawnProcess(spawnOptions);} catch (cause) {- if (signal?.aborted || cause instanceof AnalysisCancelledError)+ if (+ (signal?.aborted && cause === signal.reason) ||+ cause instanceof AnalysisCancelledError+ )return err(new AnalysisCancelledError("start_gdb_session", { cause }));return err(new AnalysisCapabilityUnavailableError(@@ -808,7 +857,6 @@ export class GdbSessionManager {);startupTimer.unref();});- session.ready = true;if (signal?.aborted)throw new AnalysisCancelledError("start_gdb_session");const autoLoad = await this.#request(@@ -873,8 +921,11 @@ export class GdbSessionManager {throw new Error(session.protocolError ?? "GDB exited during startup readiness.",);- // Before this point no target command can run. Once a usable session is- // published, the inferior state is no longer inferred from startup phase.+ // Publish readiness only after every mandatory startup check completes.+ // Retained failed-start owners remain addressable for cleanup, not work.+ session.ready = true;+ // Before publication no target command can run. Once usable, the+ // inferior state is no longer inferred from startup phase.session.noInferiorVerified = false;this.#sessions.set(id, session);releaseReservation();@@ -981,6 +1032,16 @@ export class GdbSessionManager {if (stopped.status === "incomplete") {this.#sessions.set(id, session);releaseReservation();+ const cleanupFailure = this.#retainCleanupFailure(+ session,+ "start_gdb_session",+ stopped.reason,+ { cause },+ );+ const retainCleanup = <T extends AnalysisError>(failure: T): T =>+ failure.bindCleanupDependencies([cleanupFailure], {+ cleanupResources: [session.id],+ });const cleanup = { reason: stopped.reason, resources: [session.id] };const details = {cause,@@ -992,17 +1053,27 @@ export class GdbSessionManager {};if (cause instanceof AnalysisTimeoutError)return err(- new AnalysisTimeoutError(cause.operation, cause.timeoutMs, details),+ retainCleanup(+ new AnalysisTimeoutError(+ cause.operation,+ cause.timeoutMs,+ details,+ ),+ ),);if (cause instanceof AnalysisCancelledError)- return err(new AnalysisCancelledError(cause.operation, details));+ return err(+ retainCleanup(new AnalysisCancelledError(cause.operation, details)),+ );const startupFailureMessage = gdbErrorMessage(cause);return err(- new AnalysisCapabilityUnavailableError(- "gdb",- "start_gdb_session",- `GDB startup failed (${startupFailureMessage}) and its owned process could not be confirmed stopped: ${stopped.reason}`,- details,+ retainCleanup(+ new AnalysisCapabilityUnavailableError(+ "gdb",+ "start_gdb_session",+ `GDB startup failed (${startupFailureMessage}) and its owned process could not be confirmed stopped: ${stopped.reason}`,+ details,+ ),),);}@@ -1014,7 +1085,7 @@ export class GdbSessionManager {: { partialObservation: startupEvidence }),};const error =- signal?.aborted || cause instanceof AnalysisCancelledError+ cause instanceof AnalysisCancelledError? new AnalysisCancelledError("start_gdb_session", errorDetails): cause instanceof AnalysisTimeoutError? new AnalysisTimeoutError(@@ -1078,7 +1149,8 @@ export class GdbSessionManager {},]),);- if (signal?.aborted) return err(new AnalysisCancelledError("gdb_console"));+ if (signal?.aborted)+ return err(cancelledWithCallerReason("gdb_console", signal));try {const completed = await this.#serialize(session,@@ -2047,28 +2119,51 @@ export class GdbSessionManager {"A GDB MI command was cancelled; owned-session shutdown was requested because output correlation can no longer be guaranteed.";void this.#stopDebuggerOnly(session).then((stopped) => {+ if (stopped.status !== "incomplete") {+ pending.reject(+ new AnalysisCancelledError("gdb_console", {+ cause: signal?.reason,+ partialObservation: evidence,+ }),+ );+ return;+ }+ const cleanupFailure = this.#retainCleanupFailure(+ session,+ "gdb_console",+ stopped.reason,+ );pending.reject(- stopped.status === "incomplete"- ? new AnalysisCancelledError("gdb_console", {- cause: new Error(stopped.reason),- cleanup: {- reason: stopped.reason,- resources: [session.id],- },- partialObservation: evidence,- })- : new AnalysisCancelledError("gdb_console", {- partialObservation: evidence,- }),+ new AnalysisCancelledError("gdb_console", {+ cause: signal?.reason,+ cleanup: {+ reason: stopped.reason,+ resources: [session.id],+ },+ partialObservation: evidence,+ }).bindCleanupDependencies([cleanupFailure], {+ cleanupResources: [session.id],+ }),);},- (cause: unknown) =>+ (cause: unknown) => {+ const reason = gdbErrorMessage(cause);+ const cleanupFailure = this.#retainCleanupFailure(+ session,+ "gdb_console",+ reason,+ { cause },+ );pending.reject(new AnalysisCancelledError("gdb_console", {- cause,+ cause: signal?.reason,+ cleanup: { reason, resources: [session.id] },partialObservation: evidence,+ }).bindCleanupDependencies([cleanupFailure], {+ cleanupResources: [session.id],}),- ),+ );+ },);};signal?.addEventListener("abort", abortListener, { once: true });@@ -2223,17 +2318,21 @@ export const commandMayChangeInferiorOutput = (command: string): boolean => {);};-/** Terminate only the directly owned debugger process, never its process group or inferiors. */+/** Await a serialized command turn, preserving the caller's cancellation reason. */export const waitForGdbCommandTurn = (previous: Promise<void>,signal?: AbortSignal,): Promise<void> => {if (signal === undefined) return previous;if (signal.aborted)- return Promise.reject(new AnalysisCancelledError("gdb_console"));+ return Promise.reject(+ new AnalysisCancelledError("gdb_console", { cause: signal.reason }),+ );return new Promise<void>((resolve, reject) => {const onAbort = (): void =>- reject(new AnalysisCancelledError("gdb_console"));+ reject(+ new AnalysisCancelledError("gdb_console", { cause: signal.reason }),+ );signal.addEventListener("abort", onAbort, { once: true });previous.then(() => {diff --git a/tests/boundary/mcp/gdbCancellationMcp.test.ts b/tests/boundary/mcp/gdbCancellationMcp.test.tsindex 79b7f1fce..9281ad63a 100644--- a/tests/boundary/mcp/gdbCancellationMcp.test.ts+++ b/tests/boundary/mcp/gdbCancellationMcp.test.ts@@ -18,6 +18,7 @@ import { thinMach } from "../../../src/domain/binaryTarget.fixture.js";import { err, ok } from "../../../src/domain/result.js";import { GdbSessionManager } from "../../../src/gdb/GdbSessionManager.js";import { silentLogger } from "../../../src/logger.js";+import { stopOwnedDebuggerProcess } from "../../../src/process/ownedDebuggerSession.js";import { registerGdbTools } from "../../../src/server/registerGdbTools.js";import type { GdbToolManager } from "../../../src/server/registerGdbTools.js";import { createToolResultDelivery } from "../../../src/server/toolResult.js";@@ -31,6 +32,106 @@ import {waitForStartedFile,} from "../../support/reverseDebuggerMcpTestHelpers.js";+it.skipIf(process.platform === "win32")(+ "keeps a failed GDB startup closed through MCP and retries its retained owner before console admission",+ async () => {+ const directory = await mkdtemp(join(tmpdir(), "rea-gdb-mcp-startup-"));+ const provider = join(directory, "fake-gdb.mjs");+ await writeFile(+ provider,+ `#!${process.execPath}+process.stdout.write("(gdb)\\n");+process.stdin.setEncoding("utf8");+process.stdin.on("data", (chunk) => {+ for (const line of chunk.split("\\n")) {+ const match = /^(\\d+)/.exec(line);+ if (!match) continue;+ process.stdout.write(match[1] + (line.includes("auto-load off")+ ? "^error,msg=\\"setting rejected\\"\\n"+ : "^done\\n"));+ }+});+`,+ );+ await chmod(provider, 0o700);+ let stopCalls = 0;+ let exitedDuringRetry = false;+ const manager = new GdbSessionManager({+ platform: "linux",+ environment: { REA_GDB_COMMAND: provider },+ stopProcess: async (session, name) => {+ stopCalls += 1;+ if (stopCalls === 1)+ return {+ status: "incomplete",+ reason: "simulated startup stop uncertainty",+ };+ const stopped = await stopOwnedDebuggerProcess(session, name);+ exitedDuringRetry = session.exited;+ return stopped;+ },+ });+ const server = new McpServer({+ name: "gdb-startup-readiness",+ version: "1",+ });+ registerGdbTools(+ server,+ manager,+ silentLogger,+ createToolResultDelivery(undefined),+ );+ const client = new Client({ name: "gdb-startup-readiness", version: "1" });+ const [clientTransport, serverTransport] =+ InMemoryTransport.createLinkedPair();+ try {+ await server.connect(serverTransport);+ await client.connect(clientTransport);+ const started = await client.callTool({+ name: "start_gdb_session",+ arguments: {},+ });+ expect(started.isError).toBe(true);+ expect(started.structuredContent).toMatchObject({+ error: {+ code: "cleanup_incomplete",+ details: {+ cleanup_reason: "simulated startup stop uncertainty",+ resources: [expect.stringMatching(/^[0-9a-f-]{36}$/u)],+ },+ },+ });+ const failure = z+ .object({+ error: z.object({+ details: z.object({ resources: z.tuple([z.string().uuid()]) }),+ }),+ })+ .parse(started.structuredContent);+ const sessionId = failure.error.details.resources[0];+ expect(stopCalls).toBe(1);+ expect(manager.status(sessionId)?.state).toBe("closed");+ expect(exitedDuringRetry).toBe(false);++ const command = await client.callTool({+ name: "gdb_console",+ arguments: { session_id: sessionId, command: "show version" },+ });+ expect(command.isError).toBe(true);+ expect(command.structuredContent).toMatchObject({+ error: { code: "invalid_request" },+ });+ expect(stopCalls).toBe(2);+ expect(exitedDuringRetry).toBe(true);+ expect(manager.status(sessionId)).toBeUndefined();+ } finally {+ await Promise.allSettled([client.close(), server.close()]);+ await manager.closeAll().catch(() => undefined);+ await rm(directory, { recursive: true, force: true });+ }+ },+);+it.skipIf(process.platform === "win32")("propagates MCP cancellation into a running GDB command",async () => {diff --git a/tests/boundary/providers/GdbSessionManagerCoverage.test.ts b/tests/boundary/providers/GdbSessionManagerCoverage.test.tsindex 9b768dc01..53233ce13 100644--- a/tests/boundary/providers/GdbSessionManagerCoverage.test.ts+++ b/tests/boundary/providers/GdbSessionManagerCoverage.test.ts@@ -7,7 +7,10 @@ import { PassThrough } from "node:stream";import { afterEach, expect, it } from "vitest";-import { AnalysisTimeoutError } from "../../../src/domain/analysisErrorCore.js";+import {+ AnalysisCancelledError,+ AnalysisTimeoutError,+} from "../../../src/domain/analysisErrorCore.js";import {commandMayChangeInferiorOutput,gdbErrorMessage,@@ -324,20 +327,25 @@ const recordingInferiorListResponder = (groups: string) => {it("returns cancellation when GDB startup is aborted after spawn", async () => {const controller = new AbortController();+ const reason = { source: "caller startup cancellation" };const fake = createFakeSpawner(undefined, {- afterSpawn: () => controller.abort(),+ afterSpawn: () => controller.abort(reason),});const manager = managerWithFakeSpawner(fake.spawnProcess);const started = await manager.start(controller.signal);expect(started.ok).toBe(false);- if (!started.ok) expect(started.error._tag).toBe("AnalysisCancelledError");+ if (!started.ok) {+ expect(started.error._tag).toBe("AnalysisCancelledError");+ expect(started.error.cause).toBe(reason);+ }expect(fake.children[0]?.signalCode).toBe("SIGTERM");});it("cancels immediately after the startup prompt before sending configuration commands", async () => {const controller = new AbortController();+ const reason = new Error("caller cancelled after prompt");const commands: string[] = [];const fake = createFakeSpawner((child, token, command) => {@@ -346,7 +354,7 @@ it("cancels immediately after the startup prompt before sending configuration co},{deferPrompt: true,- afterPrompt: () => controller.abort(),+ afterPrompt: () => controller.abort(reason),},);const manager = managerWithFakeSpawner(fake.spawnProcess);@@ -358,6 +366,7 @@ it("cancels immediately after the startup prompt before sending configuration coerror: { _tag: "AnalysisCancelledError" },});expect(commands).toEqual([]);+ if (!started.ok) expect(started.error.cause).toBe(reason);expect(fake.children[0]?.killSignals).toEqual(["SIGTERM"]);});@@ -376,14 +385,41 @@ it("rejects a GDB exit queued with the final startup response", async () => {expect(fake.children[0]?.exitCode).toBe(7);});+it("keeps a consumed startup failure primary when caller abort arrives during cleanup", async () => {+ const controller = new AbortController();+ const reason = { source: "late caller cancellation" };+ const fake = createFakeSpawner((_child, token, command) => {+ if (command.includes("auto-load off"))+ _child.stdout.write(`${token}^error,msg="configuration rejected"\n`);+ });+ const manager = managerWithFakeSpawner(fake.spawnProcess, {+ stopProcess: async () => {+ controller.abort(reason);+ return { status: "stopped" };+ },+ });++ const started = await manager.start(controller.signal);++ expect(started).toMatchObject({+ ok: false,+ error: { _tag: "AnalysisCapabilityUnavailableError" },+ });+ if (!started.ok)+ expect(started.error.cause).toMatchObject({+ _tag: "AnalysisCapabilityUnavailableError",+ });+});+it("cancels startup when aborted during the final readiness drain", async () => {const controller = new AbortController();+ const reason = "caller cancelled during readiness drain";const commands: string[] = [];const fake = createFakeSpawner((child, token, command) => {commands.push(command);child.stdout.write(`${token}^done\n`);if (command.includes("auto-load off"))- setImmediate(() => controller.abort());+ setImmediate(() => controller.abort(reason));});const manager = managerWithFakeSpawner(fake.spawnProcess);@@ -394,15 +430,17 @@ it("cancels startup when aborted during the final readiness drain", async () =>error: { _tag: "AnalysisCancelledError" },});expect(commands).toEqual(["-gdb-set auto-load off"]);+ if (!started.ok) expect(started.error.cause).toBe(reason);expect(fake.children[0]?.killSignals).toEqual(["SIGTERM"]);});it("preserves cancellation and cleanup details when startup stop is uncertain", async () => {const controller = new AbortController();+ const reason = { source: "startup caller", token: 7 };let stopCalls = 0;const fake = createFakeSpawner(undefined, {deferPrompt: true,- afterPrompt: () => controller.abort(),+ afterPrompt: () => controller.abort(reason),});const manager = managerWithFakeSpawner(fake.spawnProcess, {stopProcess: async (session, name) => {@@ -426,6 +464,66 @@ it("preserves cancellation and cleanup details when startup stop is uncertain",cleanup: { reason: "simulated startup cancellation cleanup uncertainty" },},});+ if (!started.ok) expect(started.error.cause).toBe(reason);+});++it("keeps manager-close cancellation primary when caller abort arrives during startup cleanup", async () => {+ const caller = new AbortController();+ const callerReason = { source: "late caller abort", token: Symbol("opaque") };+ let commandEntered!: () => void;+ const commandStarted = new Promise<void>((resolve) => {+ commandEntered = resolve;+ });+ let cleanupEntered!: () => void;+ const cleanupStarted = new Promise<void>((resolve) => {+ cleanupEntered = resolve;+ });+ let releaseCleanup!: () => void;+ const cleanupGate = new Promise<void>((resolve) => {+ releaseCleanup = resolve;+ });+ let stopCalls = 0;+ const fake = createFakeSpawner((_child, _token, command) => {+ if (command.includes("auto-load off")) commandEntered();+ });+ const manager = managerWithFakeSpawner(fake.spawnProcess, {+ stopProcess: async () => {+ stopCalls += 1;+ if (stopCalls === 1) {+ cleanupEntered();+ await cleanupGate;+ }+ return {+ status: "incomplete",+ reason: "held fake cleanup remains uncertain",+ };+ },+ });++ const starting = manager.start(caller.signal);+ await commandStarted;+ const closing = manager.closeAll().catch(() => undefined);+ await cleanupStarted;+ caller.abort(callerReason);+ releaseCleanup();+ const started = await starting;++ expect(started.ok).toBe(false);+ if (!started.ok) {+ expect(started.error).toBeInstanceOf(AnalysisCancelledError);+ expect(started.error.cause).toBeInstanceOf(AnalysisCancelledError);+ expect(started.error.cause).not.toBe(callerReason);+ expect(started.error.cleanup).toEqual({+ reason: "held fake cleanup remains uncertain",+ resources: started.error.cleanupResources,+ });+ expect(started.error.cleanupIncomplete).toBe(true);+ }+ expect(stopCalls).toBeGreaterThanOrEqual(1);+ expect(fake.children[0]?.exitCode).toBeNull();+ await closing;+ expect(stopCalls).toBeGreaterThanOrEqual(2);+ expect(fake.children[0]?.exitCode).toBeNull();});it("classifies cancellation while asynchronous GDB ownership preparation is pending", async () => {@@ -442,7 +540,7 @@ it("classifies cancellation while asynchronous GDB ownership preparation is pendentered();options.signal?.addEventListener("abort",- () => reject(new Error("spawn preparation aborted")),+ () => reject(options.signal?.reason),{ once: true },);}),@@ -1216,13 +1314,24 @@ afterEach(async () => {it("rejects a pre-cancelled GDB start and an unconfigured executable", async () => {const cancelled = new AbortController();- cancelled.abort();+ const reason = new Error("caller cancelled before start");+ cancelled.abort(reason);const startResult = await new GdbSessionManager({ platform: "linux" }).start(cancelled.signal,);expect(startResult.ok).toBe(false);- if (!startResult.ok)+ if (!startResult.ok) {expect(startResult.error._tag).toBe("AnalysisCancelledError");+ expect(startResult.error.cause).toBe(reason);+ }++ const nullReasonController = new AbortController();+ nullReasonController.abort(null);+ const nullReasonResult = await new GdbSessionManager({+ platform: "linux",+ }).start(nullReasonController.signal);+ expect(nullReasonResult.ok).toBe(false);+ if (!nullReasonResult.ok) expect(nullReasonResult.error.cause).toBeNull();const missing = await new GdbSessionManager({platform: "linux",@@ -1281,6 +1390,90 @@ it("retains ownership when GDB startup fails before its prompt and stop is incomexpect(manager.status(retainedSessionId ?? "")?.state).toBe("closed");});+it.each([+ ["required auto-load configuration", "auto-load"],+ ["caller-selected inferior TTY", "tty"],+ ["late startup cancellation", "cancel"],+] as const)(+ "keeps an incompletely stopped failed startup unavailable and retriable after %s",+ async (_label, failure) => {+ const controller = new AbortController();+ const commands: string[] = [];+ let stopCalls = 0;+ const fake = createFakeSpawner((child, token, command) => {+ commands.push(command);+ if (failure === "auto-load" && command.includes("auto-load off")) {+ child.stdout.write(`${token}^error,msg="setting rejected"\n`);+ } else if (failure === "tty" && command.includes("inferior-tty-show")) {+ child.stdout.write(+ `${token}^done,inferior_tty_terminal="/dev/pts/8"\n`,+ );+ } else {+ child.stdout.write(`${token}^done\n`);+ }+ // The MI response is complete, but the startup continuation has not yet+ // observed it. This exercises cancellation between, not during, requests.+ if (failure === "cancel" && command.includes("auto-load off"))+ controller.abort();+ });+ const manager = managerWithFakeSpawner(fake.spawnProcess, {+ stopProcess: async (session, name) => {+ stopCalls += 1;+ return stopCalls === 1+ ? {+ status: "incomplete",+ reason: "simulated startup stop uncertainty",+ }+ : stopOwnedDebuggerProcess(session, name);+ },+ });++ const started = await manager.start(+ failure === "cancel" ? controller.signal : undefined,+ failure === "tty" ? { inferiorTty: "/dev/pts/7" } : {},+ );++ expect(started.ok).toBe(false);+ if (started.ok) return;+ expect(started.error._tag).toBe(+ failure === "cancel"+ ? "AnalysisCancelledError"+ : "AnalysisCapabilityUnavailableError",+ );+ expect(started.error.cause).toBeDefined();+ expect(started.error.partialObservation).toMatchObject({+ predicate_type: "rea.debugger.startup-observation",+ });+ expect(started.error.cleanup).toMatchObject({+ reason: "simulated startup stop uncertainty",+ });+ expect(started.error.cleanupIncomplete).toBe(true);+ const [sessionId] = started.error.cleanupResources;+ if (sessionId === undefined)+ throw new Error("Failed startup did not retain its GDB session ID.");+ expect(sessionId).toMatch(/^[0-9a-f-]{36}$/u);+ expect(started.error.cleanup?.resources).toEqual([sessionId]);+ expect(stopCalls).toBe(1);+ expect(fake.children[0]?.exitCode).toBeNull();+ expect(manager.status(sessionId)?.state).toBe("closed");++ const command = await manager.execute(sessionId, "show version");+ expect(command).toMatchObject({+ ok: false,+ error: { _tag: "AnalysisInputError" },+ });+ expect(commands).not.toContain('-interpreter-exec console "show version"');+ expect(fake.children[0]?.exitCode).toBeNull();++ expect((await manager.retryCleanupFailures()).ok).toBe(true);+ expect(stopCalls).toBe(2);+ expect(started.error.cleanupIncomplete).toBe(false);+ expect(manager.status(sessionId)).toBeUndefined();+ expect(fake.children[0]?.exitCode).toBeNull();+ expect(fake.children[0]?.signalCode).toBe("SIGTERM");+ },+);+it("uses a fallback message when the process launcher rejects without an Error", async () => {let attempts = 0;const manager = managerWithFakeSpawner(async () => {@@ -1677,20 +1870,26 @@ it("waits for the prior command and preserves cancellation and queue failures",expect(waitForGdbCommandTurn(resolved)).toBe(resolved);const preAborted = new AbortController();- preAborted.abort();+ const queueReason = "queue cancelled before admission";+ preAborted.abort(queueReason);await expect(waitForGdbCommandTurn(Promise.resolve(), preAborted.signal),- ).rejects.toMatchObject({ _tag: "AnalysisCancelledError" });+ ).rejects.toMatchObject({+ _tag: "AnalysisCancelledError",+ cause: queueReason,+ });let release!: () => void;const pending = new Promise<void>((resolve) => {release = resolve;});const controller = new AbortController();+ const activeQueueReason = { source: "active queue cancellation" };const cancelledWait = waitForGdbCommandTurn(pending, controller.signal);- controller.abort();+ controller.abort(activeQueueReason);await expect(cancelledWait).rejects.toMatchObject({_tag: "AnalysisCancelledError",+ cause: activeQueueReason,});release();@@ -2439,18 +2638,20 @@ it("preserves a command timeout when stopping the owned process rejects", async}});-it("reports cancellation if owned-process stop rejects during an active command", async () => {+it("retains caller cancellation and cleanup authority after active-command stop rejects", async () => {const controller = new AbortController();+ const reason = { source: "console caller cancellation" };+ const cleanupFailure = new AnalysisTimeoutError("foreign_cleanup", 17);let stopCalls = 0;const fake = createFakeSpawner((child, token, command) => {if (command.includes("auto-load off"))child.stdout.write(`${token}^done\n`);- else controller.abort();+ else controller.abort(reason);});const manager = managerWithFakeSpawner(fake.spawnProcess, {stopProcess: async (session, name) => {stopCalls += 1;- if (stopCalls === 1) throw new Error("simulated stop rejection");+ if (stopCalls === 1) throw cleanupFailure;return stopOwnedDebuggerProcess(session, name);},});@@ -2463,9 +2664,19 @@ it("reports cancellation if owned-process stop rejects during an active command");expect(cancelled.ok).toBe(false);- if (!cancelled.ok)+ if (!cancelled.ok) {expect(cancelled.error._tag).toBe("AnalysisCancelledError");+ expect(cancelled.error.cause).toBe(reason);+ expect(cancelled.error.cleanup).toEqual({+ reason: expect.stringContaining("foreign_cleanup"),+ resources: [started.value.session_id],+ });+ expect(cancelled.error.cleanupIncomplete).toBe(true);+ }expect(stopCalls).toBe(1);+ expect((await manager.retryCleanupFailures()).ok).toBe(false);+ if (!cancelled.ok) expect(cancelled.error.cleanupIncomplete).toBe(true);+ expect(stopCalls).toBe(2);});it("returns a tagged cleanup failure thrown while closing", async () => {@@ -2530,6 +2741,7 @@ it("returns partial command evidence when the active MI request times out afterit("preserves cancellation without cleanup details when stop is confirmed", async () => {const controller = new AbortController();+ const reason = { source: "confirmed active command cancellation" };let requestToken = "";const fake = createFakeSpawner((_child, token, command) => {if (command.includes("cancel-confirmed")) requestToken = token;@@ -2546,14 +2758,17 @@ it("preserves cancellation without cleanup details when stop is confirmed", asyncontroller.signal,);await expect.poll(() => requestToken).not.toBe("");- controller.abort();+ controller.abort(reason);const cancelled = await active;expect(cancelled).toMatchObject({ok: false,error: { _tag: "AnalysisCancelledError", operation: "gdb_console" },});- if (!cancelled.ok) expect(cancelled.error.cleanup).toBeUndefined();+ if (!cancelled.ok) {+ expect(cancelled.error.cleanup).toBeUndefined();+ expect(cancelled.error.cause).toBe(reason);+ }});it("rechecks cancellation after registering the active MI request listener", async () => {