c64-debug-mcp 1.0.12 → 1.0.14

package/dist/http.cjs

@@ -66,7 +66,7 @@ var stopReasonSchema = import_zod.z.enum([
 ]);
 var sessionHealthSchema = import_zod.z.enum(["not_configured", "starting", "ready", "recovering", "stopped", "error"]);
 var breakpointKindSchema = import_zod.z.enum(["exec", "read", "write", "read_write"]);
-var resetModeSchema = import_zod.z.enum(["soft", "hard"]);
+var resetModeSchema = import_zod.z.enum(["soft", "hard", "nuclear"]);
 var inputActionSchema = import_zod.z.enum(["press", "release", "tap"]);
 var joystickControlSchema = import_zod.z.enum(["up", "down", "left", "right", "fire"]);
 var joystickPortSchema = import_zod.z.union([import_zod.z.literal(1), import_zod.z.literal(2)]);
@@ -1728,7 +1728,17 @@ var ViceSession = class {
       }
       this.#syncMonitorRuntimeState();
       if (!this.#suppressRecovery && !this.#shuttingDown && this.#config) {
-        void this.#scheduleRecovery();
+        void this.#scheduleRecovery().catch((error) => {
+          this.#writeProcessLogLine(`[recovery-error] ${error instanceof Error ? error.message : String(error)}`);
+        });
+      }
+    });
+    this.#client.on("transport-error", (error) => {
+      this.#writeProcessLogLine(`[monitor-error] transport error: ${error.message}`);
+      if (!this.#suppressRecovery && !this.#shuttingDown && this.#config) {
+        void this.#scheduleRecovery().catch((recoveryError) => {
+          this.#writeProcessLogLine(`[recovery-error] ${recoveryError instanceof Error ? recoveryError.message : String(recoveryError)}`);
+        });
       }
     });
     this.#client.on("event", (event) => {
@@ -2069,6 +2079,10 @@ var ViceSession = class {
   async resetMachine(mode) {
     return this.#withExecutionLock(async () => {
       await this.#ensureReady();
+      this.#clearHeldInputState();
+      if (mode === "nuclear") {
+        return await this.#performNuclearReset();
+      }
       const wasPaused = this.#explicitPauseActive;
       this.#lastExecutionIntent = "reset";
       this.#writeProcessLogLine(`[tx] execute reset mode=${mode}`);
@@ -2088,6 +2102,67 @@ var ViceSession = class {
       };
     });
   }
+  async #performNuclearReset() {
+    const savedBreakpoints = await this.#captureBreakpointState();
+    const wasPaused = this.#explicitPauseActive;
+    this.#writeProcessLogLine("[nuclear-reset] initiating full VICE process restart");
+    await this.#scheduleRecovery();
+    await this.#restoreBreakpointState(savedBreakpoints);
+    this.#explicitPauseActive = wasPaused;
+    if (wasPaused) {
+      this.#writeProcessLogLine("[nuclear-reset] restoring paused state");
+      await this.pauseExecution();
+    }
+    this.#writeProcessLogLine("[nuclear-reset] completed successfully");
+    const debugState = await this.#readDebugState();
+    return {
+      executionState: debugState.executionState,
+      lastStopReason: debugState.lastStopReason,
+      programCounter: debugState.programCounter,
+      registers: debugState.registers,
+      warnings: []
+    };
+  }
+  async #captureBreakpointState() {
+    try {
+      const result = await this.listBreakpoints(true);
+      return result.breakpoints.map((bp) => ({
+        kind: bp.kind,
+        start: bp.start,
+        end: bp.end,
+        enabled: bp.enabled,
+        temporary: bp.temporary,
+        hasCondition: bp.hasCondition,
+        label: this.#breakpointLabels.get(bp.id) ?? null
+      }));
+    } catch (error) {
+      this.#writeProcessLogLine(`[nuclear-reset] failed to capture breakpoints: ${error instanceof Error ? error.message : String(error)}`);
+      return [];
+    }
+  }
+  async #restoreBreakpointState(savedBreakpoints) {
+    if (savedBreakpoints.length === 0) {
+      return;
+    }
+    this.#writeProcessLogLine(`[nuclear-reset] restoring ${savedBreakpoints.length} breakpoints`);
+    for (const bp of savedBreakpoints) {
+      try {
+        await this.breakpointSet({
+          kind: bp.kind,
+          address: bp.start,
+          length: bp.end - bp.start + 1,
+          enabled: bp.enabled,
+          temporary: bp.temporary,
+          label: bp.label ?? void 0
+        });
+        this.#writeProcessLogLine(`[nuclear-reset] restored breakpoint at $${bp.start.toString(16).toUpperCase()}`);
+      } catch (error) {
+        this.#writeProcessLogLine(
+          `[nuclear-reset] failed to restore breakpoint at $${bp.start.toString(16).toUpperCase()}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
   async listBreakpoints(includeDisabled = true) {
     await this.#ensureReady();
     this.#writeProcessLogLine(`[tx] breakpoint_list includeDisabled=${includeDisabled}`);
@@ -2802,7 +2877,9 @@ var ViceSession = class {
         makeWarning(`C64 emulator process exited (${code ?? "null"} / ${signal ?? "null"})`, "process_exit")
       ];
       if (!this.#suppressRecovery && !this.#shuttingDown && this.#config) {
-        void this.#scheduleRecovery();
+        void this.#scheduleRecovery().catch((error) => {
+          this.#writeProcessLogLine(`[recovery-error] ${error instanceof Error ? error.message : String(error)}`);
+        });
       }
     });
     child.once("error", (error) => {
@@ -2815,12 +2892,16 @@ var ViceSession = class {
       this.#transportState = "faulted";
       this.#warnings = [...this.#warnings.filter((warning) => warning.code !== "process_error"), makeWarning(error.message, "process_error")];
       if (!this.#suppressRecovery && !this.#shuttingDown && this.#config) {
-        void this.#scheduleRecovery();
+        void this.#scheduleRecovery().catch((error2) => {
+          this.#writeProcessLogLine(`[recovery-error] ${error2 instanceof Error ? error2.message : String(error2)}`);
+        });
       }
     });
   }
   #attachProcessLogging(child, binary, args) {
     const logStream = (0, import_node_fs.createWriteStream)(VICE_PROCESS_LOG_PATH, { flags: "a" });
+    logStream.on("error", () => {
+    });
     this.#processLogStream = logStream;
     this.#stdoutMirrorBuffer = "";
     this.#stderrMirrorBuffer = "";
@@ -2854,7 +2935,10 @@ var ViceSession = class {
     logStream.write(`
 === Emulator stream closed ${nowIso()} (${reason}) ===
 `);
-    logStream.end();
+    logStream.end(() => {
+    });
+    logStream.on("error", () => {
+    });
     this.#processLogStream = null;
   }
   #mirrorViceOutputChunk(stream, chunk) {
@@ -3636,40 +3720,35 @@ var setRegistersTool = createViceTool({
 });
 var readMemoryTool = createViceTool({
   id: "memory_read",
-  description: "Reads a memory chunk. Use either (address, length) or (start, end) format. Addresses can be decimal (53248) or hex string with prefix ($D000, 0xD000). Returns byte values as decimal numbers.",
-  inputSchema: import_zod4.z.union([
-    import_zod4.z.object({
-      address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      length: import_zod4.z.number().int().positive().max(65535).describe("Number of bytes to read")
-    }).refine((input) => input.address + input.length <= 65536, {
-      message: "address + length must stay within the 64K address space",
-      path: ["length"]
-    }),
-    import_zod4.z.object({
-      start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)")
-    }).refine((input) => input.start <= input.end, {
-      message: "End address must be greater than or equal to start address",
-      path: ["end"]
-    }).refine((input) => input.end < 65536, {
-      message: "End address must stay within the 64K address space",
-      path: ["end"]
-    })
-  ]),
+  description: "Reads a memory chunk. Specify start_address and either data_length or end_address. Address can be decimal (53248) or hex string with prefix ($D000, 0xD000). Returns byte values as decimal numbers.",
+  inputSchema: import_zod4.z.object({
+    start_address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+    data_length: import_zod4.z.number().int().positive().max(65535).optional().describe("Number of bytes to read (use either data_length or end_address)"),
+    end_address: address16Schema.optional().describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000). Use either data_length or end_address.")
+  }),
   dataSchema: import_zod4.z.object({
-    address: import_zod4.z.number().int().min(0).max(65535).describe("Start address of the returned memory chunk"),
+    address: address16Schema.describe("Start address of the returned memory chunk"),
     length: import_zod4.z.number().int().min(0).describe("Number of bytes returned"),
     data: byteArraySchema.describe("Raw bytes returned from memory")
   }),
   execute: async (input) => {
-    let address;
+    const address = input.start_address;
     let length;
-    if ("start" in input && "end" in input) {
-      address = input.start;
-      length = input.end - input.start + 1;
+    if (input.end_address !== void 0) {
+      if (address > input.end_address) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      if (input.end_address >= 65536) {
+        throw new Error("End address must stay within the 64K address space");
+      }
+      length = input.end_address - address + 1;
+    } else if (input.data_length !== void 0) {
+      length = input.data_length;
+      if (address + length > 65536) {
+        throw new Error("address + length must stay within the 64K address space");
+      }
     } else {
-      address = input.address;
-      length = input.length;
+      throw new Error("Must provide either data_length or end_address");
     }
     const result = await c64Session.readMemory(address, address + length - 1);
     return {
@@ -3691,7 +3770,7 @@ var writeMemoryTool = createViceTool({
   }),
   dataSchema: import_zod4.z.object({
     worked: import_zod4.z.boolean().describe("Whether the write operation completed successfully"),
-    address: import_zod4.z.number().int().min(0).max(65535).describe("Start address where the bytes were written"),
+    address: address16Schema.describe("Start address where the bytes were written"),
     length: import_zod4.z.number().int().min(1).describe("Number of bytes written")
   }).extend(debugStateSchema.shape),
   execute: async (input) => await c64Session.writeMemory(input.address, input.data)
@@ -3702,7 +3781,7 @@ var executeTool = createViceTool({
   inputSchema: import_zod4.z.object({
     action: import_zod4.z.enum(["pause", "resume", "step", "step_over", "step_out", "reset"]),
     count: import_zod4.z.number().int().positive().default(1).describe("Instruction count for step and step_over actions"),
-    resetMode: resetModeSchema.default("soft").describe("Reset mode when action is reset"),
+    resetMode: resetModeSchema.default("soft").describe("Reset mode: soft (CPU reset), hard (full machine reset), or nuclear (complete VICE restart)"),
     waitUntilRunningStable: import_zod4.z.boolean().default(false).describe("When action is resume, wait until running becomes stable before returning")
   }),
   dataSchema: debugStateSchema.extend({
@@ -3740,47 +3819,44 @@ var listBreakpointsTool = createViceTool({
 });
 var breakpointSetTool = createViceTool({
   id: "breakpoint_set",
-  description: "Creates an execution breakpoint or read/write watchpoint. Use either (address, length) or (start, end) format. Addresses can be decimal (53248) or hex string with prefix ($D000, 0xD000).",
-  inputSchema: import_zod4.z.union([
-    import_zod4.z.object({
-      kind: breakpointKindSchema,
-      address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      length: import_zod4.z.number().int().positive().default(1).describe("Size of the breakpoint range in bytes"),
-      condition: import_zod4.z.string().optional(),
-      label: import_zod4.z.string().optional(),
-      temporary: import_zod4.z.boolean().default(false),
-      enabled: import_zod4.z.boolean().default(true)
-    }),
-    import_zod4.z.object({
-      kind: breakpointKindSchema,
-      start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      condition: import_zod4.z.string().optional(),
-      label: import_zod4.z.string().optional(),
-      temporary: import_zod4.z.boolean().default(false),
-      enabled: import_zod4.z.boolean().default(true)
-    }).refine((input) => input.start <= input.end, {
-      message: "End address must be greater than or equal to start address",
-      path: ["end"]
-    })
-  ]),
+  description: "Creates an execution breakpoint or read/write watchpoint. Specify start_address and either data_length or end_address. Address can be decimal (53248) or hex string with prefix ($D000, 0xD000).",
+  inputSchema: import_zod4.z.object({
+    kind: breakpointKindSchema,
+    start_address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+    data_length: import_zod4.z.number().int().positive().default(1).describe("Size of the breakpoint range in bytes (use either data_length or end_address)"),
+    end_address: address16Schema.optional().describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000). Use either data_length or end_address."),
+    condition: import_zod4.z.string().optional(),
+    label: import_zod4.z.string().optional(),
+    temporary: import_zod4.z.boolean().default(false),
+    enabled: import_zod4.z.boolean().default(true)
+  }),
   dataSchema: import_zod4.z.object({
     breakpoint: breakpointSchema,
     executionState: executionStateSchema,
     lastStopReason: stopReasonSchema,
-    programCounter: import_zod4.z.number().int().min(0).max(65535).nullable(),
+    programCounter: address16Schema.nullable(),
     registers: c64PartialRegisterValueSchema.nullable()
   }),
   execute: async (input) => {
-    const normalizedInput = "start" in input && "end" in input ? {
+    const address = input.start_address;
+    let length;
+    if (input.end_address !== void 0) {
+      if (address > input.end_address) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      length = input.end_address - address + 1;
+    } else {
+      length = input.data_length;
+    }
+    const normalizedInput = {
       kind: input.kind,
-      address: input.start,
-      length: input.end - input.start + 1,
+      address,
+      length,
       condition: input.condition,
       label: input.label,
       temporary: input.temporary,
       enabled: input.enabled
-    } : input;
+    };
     const result = await c64Session.breakpointSet(normalizedInput);
     return {
       breakpoint: normalizeBreakpoint(result.breakpoint),

package/dist/http.js

@@ -43,7 +43,7 @@ var stopReasonSchema = z.enum([
 ]);
 var sessionHealthSchema = z.enum(["not_configured", "starting", "ready", "recovering", "stopped", "error"]);
 var breakpointKindSchema = z.enum(["exec", "read", "write", "read_write"]);
-var resetModeSchema = z.enum(["soft", "hard"]);
+var resetModeSchema = z.enum(["soft", "hard", "nuclear"]);
 var inputActionSchema = z.enum(["press", "release", "tap"]);
 var joystickControlSchema = z.enum(["up", "down", "left", "right", "fire"]);
 var joystickPortSchema = z.union([z.literal(1), z.literal(2)]);
@@ -1705,7 +1705,17 @@ var ViceSession = class {
       }
       this.#syncMonitorRuntimeState();
       if (!this.#suppressRecovery && !this.#shuttingDown && this.#config) {
-        void this.#scheduleRecovery();
+        void this.#scheduleRecovery().catch((error) => {
+          this.#writeProcessLogLine(`[recovery-error] ${error instanceof Error ? error.message : String(error)}`);
+        });
+      }
+    });
+    this.#client.on("transport-error", (error) => {
+      this.#writeProcessLogLine(`[monitor-error] transport error: ${error.message}`);
+      if (!this.#suppressRecovery && !this.#shuttingDown && this.#config) {
+        void this.#scheduleRecovery().catch((recoveryError) => {
+          this.#writeProcessLogLine(`[recovery-error] ${recoveryError instanceof Error ? recoveryError.message : String(recoveryError)}`);
+        });
       }
     });
     this.#client.on("event", (event) => {
@@ -2046,6 +2056,10 @@ var ViceSession = class {
   async resetMachine(mode) {
     return this.#withExecutionLock(async () => {
       await this.#ensureReady();
+      this.#clearHeldInputState();
+      if (mode === "nuclear") {
+        return await this.#performNuclearReset();
+      }
       const wasPaused = this.#explicitPauseActive;
       this.#lastExecutionIntent = "reset";
       this.#writeProcessLogLine(`[tx] execute reset mode=${mode}`);
@@ -2065,6 +2079,67 @@ var ViceSession = class {
       };
     });
   }
+  async #performNuclearReset() {
+    const savedBreakpoints = await this.#captureBreakpointState();
+    const wasPaused = this.#explicitPauseActive;
+    this.#writeProcessLogLine("[nuclear-reset] initiating full VICE process restart");
+    await this.#scheduleRecovery();
+    await this.#restoreBreakpointState(savedBreakpoints);
+    this.#explicitPauseActive = wasPaused;
+    if (wasPaused) {
+      this.#writeProcessLogLine("[nuclear-reset] restoring paused state");
+      await this.pauseExecution();
+    }
+    this.#writeProcessLogLine("[nuclear-reset] completed successfully");
+    const debugState = await this.#readDebugState();
+    return {
+      executionState: debugState.executionState,
+      lastStopReason: debugState.lastStopReason,
+      programCounter: debugState.programCounter,
+      registers: debugState.registers,
+      warnings: []
+    };
+  }
+  async #captureBreakpointState() {
+    try {
+      const result = await this.listBreakpoints(true);
+      return result.breakpoints.map((bp) => ({
+        kind: bp.kind,
+        start: bp.start,
+        end: bp.end,
+        enabled: bp.enabled,
+        temporary: bp.temporary,
+        hasCondition: bp.hasCondition,
+        label: this.#breakpointLabels.get(bp.id) ?? null
+      }));
+    } catch (error) {
+      this.#writeProcessLogLine(`[nuclear-reset] failed to capture breakpoints: ${error instanceof Error ? error.message : String(error)}`);
+      return [];
+    }
+  }
+  async #restoreBreakpointState(savedBreakpoints) {
+    if (savedBreakpoints.length === 0) {
+      return;
+    }
+    this.#writeProcessLogLine(`[nuclear-reset] restoring ${savedBreakpoints.length} breakpoints`);
+    for (const bp of savedBreakpoints) {
+      try {
+        await this.breakpointSet({
+          kind: bp.kind,
+          address: bp.start,
+          length: bp.end - bp.start + 1,
+          enabled: bp.enabled,
+          temporary: bp.temporary,
+          label: bp.label ?? void 0
+        });
+        this.#writeProcessLogLine(`[nuclear-reset] restored breakpoint at $${bp.start.toString(16).toUpperCase()}`);
+      } catch (error) {
+        this.#writeProcessLogLine(
+          `[nuclear-reset] failed to restore breakpoint at $${bp.start.toString(16).toUpperCase()}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
   async listBreakpoints(includeDisabled = true) {
     await this.#ensureReady();
     this.#writeProcessLogLine(`[tx] breakpoint_list includeDisabled=${includeDisabled}`);
@@ -2779,7 +2854,9 @@ var ViceSession = class {
         makeWarning(`C64 emulator process exited (${code ?? "null"} / ${signal ?? "null"})`, "process_exit")
       ];
       if (!this.#suppressRecovery && !this.#shuttingDown && this.#config) {
-        void this.#scheduleRecovery();
+        void this.#scheduleRecovery().catch((error) => {
+          this.#writeProcessLogLine(`[recovery-error] ${error instanceof Error ? error.message : String(error)}`);
+        });
       }
     });
     child.once("error", (error) => {
@@ -2792,12 +2869,16 @@ var ViceSession = class {
       this.#transportState = "faulted";
       this.#warnings = [...this.#warnings.filter((warning) => warning.code !== "process_error"), makeWarning(error.message, "process_error")];
       if (!this.#suppressRecovery && !this.#shuttingDown && this.#config) {
-        void this.#scheduleRecovery();
+        void this.#scheduleRecovery().catch((error2) => {
+          this.#writeProcessLogLine(`[recovery-error] ${error2 instanceof Error ? error2.message : String(error2)}`);
+        });
       }
     });
   }
   #attachProcessLogging(child, binary, args) {
     const logStream = createWriteStream(VICE_PROCESS_LOG_PATH, { flags: "a" });
+    logStream.on("error", () => {
+    });
     this.#processLogStream = logStream;
     this.#stdoutMirrorBuffer = "";
     this.#stderrMirrorBuffer = "";
@@ -2831,7 +2912,10 @@ var ViceSession = class {
     logStream.write(`
 === Emulator stream closed ${nowIso()} (${reason}) ===
 `);
-    logStream.end();
+    logStream.end(() => {
+    });
+    logStream.on("error", () => {
+    });
     this.#processLogStream = null;
   }
   #mirrorViceOutputChunk(stream, chunk) {
@@ -3613,40 +3697,35 @@ var setRegistersTool = createViceTool({
 });
 var readMemoryTool = createViceTool({
   id: "memory_read",
-  description: "Reads a memory chunk. Use either (address, length) or (start, end) format. Addresses can be decimal (53248) or hex string with prefix ($D000, 0xD000). Returns byte values as decimal numbers.",
-  inputSchema: z3.union([
-    z3.object({
-      address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      length: z3.number().int().positive().max(65535).describe("Number of bytes to read")
-    }).refine((input) => input.address + input.length <= 65536, {
-      message: "address + length must stay within the 64K address space",
-      path: ["length"]
-    }),
-    z3.object({
-      start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)")
-    }).refine((input) => input.start <= input.end, {
-      message: "End address must be greater than or equal to start address",
-      path: ["end"]
-    }).refine((input) => input.end < 65536, {
-      message: "End address must stay within the 64K address space",
-      path: ["end"]
-    })
-  ]),
+  description: "Reads a memory chunk. Specify start_address and either data_length or end_address. Address can be decimal (53248) or hex string with prefix ($D000, 0xD000). Returns byte values as decimal numbers.",
+  inputSchema: z3.object({
+    start_address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+    data_length: z3.number().int().positive().max(65535).optional().describe("Number of bytes to read (use either data_length or end_address)"),
+    end_address: address16Schema.optional().describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000). Use either data_length or end_address.")
+  }),
   dataSchema: z3.object({
-    address: z3.number().int().min(0).max(65535).describe("Start address of the returned memory chunk"),
+    address: address16Schema.describe("Start address of the returned memory chunk"),
     length: z3.number().int().min(0).describe("Number of bytes returned"),
     data: byteArraySchema.describe("Raw bytes returned from memory")
   }),
   execute: async (input) => {
-    let address;
+    const address = input.start_address;
     let length;
-    if ("start" in input && "end" in input) {
-      address = input.start;
-      length = input.end - input.start + 1;
+    if (input.end_address !== void 0) {
+      if (address > input.end_address) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      if (input.end_address >= 65536) {
+        throw new Error("End address must stay within the 64K address space");
+      }
+      length = input.end_address - address + 1;
+    } else if (input.data_length !== void 0) {
+      length = input.data_length;
+      if (address + length > 65536) {
+        throw new Error("address + length must stay within the 64K address space");
+      }
     } else {
-      address = input.address;
-      length = input.length;
+      throw new Error("Must provide either data_length or end_address");
     }
     const result = await c64Session.readMemory(address, address + length - 1);
     return {
@@ -3668,7 +3747,7 @@ var writeMemoryTool = createViceTool({
   }),
   dataSchema: z3.object({
     worked: z3.boolean().describe("Whether the write operation completed successfully"),
-    address: z3.number().int().min(0).max(65535).describe("Start address where the bytes were written"),
+    address: address16Schema.describe("Start address where the bytes were written"),
     length: z3.number().int().min(1).describe("Number of bytes written")
   }).extend(debugStateSchema.shape),
   execute: async (input) => await c64Session.writeMemory(input.address, input.data)
@@ -3679,7 +3758,7 @@ var executeTool = createViceTool({
   inputSchema: z3.object({
     action: z3.enum(["pause", "resume", "step", "step_over", "step_out", "reset"]),
     count: z3.number().int().positive().default(1).describe("Instruction count for step and step_over actions"),
-    resetMode: resetModeSchema.default("soft").describe("Reset mode when action is reset"),
+    resetMode: resetModeSchema.default("soft").describe("Reset mode: soft (CPU reset), hard (full machine reset), or nuclear (complete VICE restart)"),
     waitUntilRunningStable: z3.boolean().default(false).describe("When action is resume, wait until running becomes stable before returning")
   }),
   dataSchema: debugStateSchema.extend({
@@ -3717,47 +3796,44 @@ var listBreakpointsTool = createViceTool({
 });
 var breakpointSetTool = createViceTool({
   id: "breakpoint_set",
-  description: "Creates an execution breakpoint or read/write watchpoint. Use either (address, length) or (start, end) format. Addresses can be decimal (53248) or hex string with prefix ($D000, 0xD000).",
-  inputSchema: z3.union([
-    z3.object({
-      kind: breakpointKindSchema,
-      address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      length: z3.number().int().positive().default(1).describe("Size of the breakpoint range in bytes"),
-      condition: z3.string().optional(),
-      label: z3.string().optional(),
-      temporary: z3.boolean().default(false),
-      enabled: z3.boolean().default(true)
-    }),
-    z3.object({
-      kind: breakpointKindSchema,
-      start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      condition: z3.string().optional(),
-      label: z3.string().optional(),
-      temporary: z3.boolean().default(false),
-      enabled: z3.boolean().default(true)
-    }).refine((input) => input.start <= input.end, {
-      message: "End address must be greater than or equal to start address",
-      path: ["end"]
-    })
-  ]),
+  description: "Creates an execution breakpoint or read/write watchpoint. Specify start_address and either data_length or end_address. Address can be decimal (53248) or hex string with prefix ($D000, 0xD000).",
+  inputSchema: z3.object({
+    kind: breakpointKindSchema,
+    start_address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+    data_length: z3.number().int().positive().default(1).describe("Size of the breakpoint range in bytes (use either data_length or end_address)"),
+    end_address: address16Schema.optional().describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000). Use either data_length or end_address."),
+    condition: z3.string().optional(),
+    label: z3.string().optional(),
+    temporary: z3.boolean().default(false),
+    enabled: z3.boolean().default(true)
+  }),
   dataSchema: z3.object({
     breakpoint: breakpointSchema,
     executionState: executionStateSchema,
     lastStopReason: stopReasonSchema,
-    programCounter: z3.number().int().min(0).max(65535).nullable(),
+    programCounter: address16Schema.nullable(),
     registers: c64PartialRegisterValueSchema.nullable()
   }),
   execute: async (input) => {
-    const normalizedInput = "start" in input && "end" in input ? {
+    const address = input.start_address;
+    let length;
+    if (input.end_address !== void 0) {
+      if (address > input.end_address) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      length = input.end_address - address + 1;
+    } else {
+      length = input.data_length;
+    }
+    const normalizedInput = {
       kind: input.kind,
-      address: input.start,
-      length: input.end - input.start + 1,
+      address,
+      length,
       condition: input.condition,
       label: input.label,
       temporary: input.temporary,
       enabled: input.enabled
-    } : input;
+    };
     const result = await c64Session.breakpointSet(normalizedInput);
     return {
       breakpoint: normalizeBreakpoint(result.breakpoint),

package/dist/stdio.cjs

@@ -63,7 +63,7 @@ var stopReasonSchema = import_zod.z.enum([
 ]);
 var sessionHealthSchema = import_zod.z.enum(["not_configured", "starting", "ready", "recovering", "stopped", "error"]);
 var breakpointKindSchema = import_zod.z.enum(["exec", "read", "write", "read_write"]);
-var resetModeSchema = import_zod.z.enum(["soft", "hard"]);
+var resetModeSchema = import_zod.z.enum(["soft", "hard", "nuclear"]);
 var inputActionSchema = import_zod.z.enum(["press", "release", "tap"]);
 var joystickControlSchema = import_zod.z.enum(["up", "down", "left", "right", "fire"]);
 var joystickPortSchema = import_zod.z.union([import_zod.z.literal(1), import_zod.z.literal(2)]);
@@ -1725,7 +1725,17 @@ var ViceSession = class {
       }
       this.#syncMonitorRuntimeState();
       if (!this.#suppressRecovery && !this.#shuttingDown && this.#config) {
-        void this.#scheduleRecovery();
+        void this.#scheduleRecovery().catch((error) => {
+          this.#writeProcessLogLine(`[recovery-error] ${error instanceof Error ? error.message : String(error)}`);
+        });
+      }
+    });
+    this.#client.on("transport-error", (error) => {
+      this.#writeProcessLogLine(`[monitor-error] transport error: ${error.message}`);
+      if (!this.#suppressRecovery && !this.#shuttingDown && this.#config) {
+        void this.#scheduleRecovery().catch((recoveryError) => {
+          this.#writeProcessLogLine(`[recovery-error] ${recoveryError instanceof Error ? recoveryError.message : String(recoveryError)}`);
+        });
       }
     });
     this.#client.on("event", (event) => {
@@ -2066,6 +2076,10 @@ var ViceSession = class {
   async resetMachine(mode) {
     return this.#withExecutionLock(async () => {
       await this.#ensureReady();
+      this.#clearHeldInputState();
+      if (mode === "nuclear") {
+        return await this.#performNuclearReset();
+      }
       const wasPaused = this.#explicitPauseActive;
       this.#lastExecutionIntent = "reset";
       this.#writeProcessLogLine(`[tx] execute reset mode=${mode}`);
@@ -2085,6 +2099,67 @@ var ViceSession = class {
       };
     });
   }
+  async #performNuclearReset() {
+    const savedBreakpoints = await this.#captureBreakpointState();
+    const wasPaused = this.#explicitPauseActive;
+    this.#writeProcessLogLine("[nuclear-reset] initiating full VICE process restart");
+    await this.#scheduleRecovery();
+    await this.#restoreBreakpointState(savedBreakpoints);
+    this.#explicitPauseActive = wasPaused;
+    if (wasPaused) {
+      this.#writeProcessLogLine("[nuclear-reset] restoring paused state");
+      await this.pauseExecution();
+    }
+    this.#writeProcessLogLine("[nuclear-reset] completed successfully");
+    const debugState = await this.#readDebugState();
+    return {
+      executionState: debugState.executionState,
+      lastStopReason: debugState.lastStopReason,
+      programCounter: debugState.programCounter,
+      registers: debugState.registers,
+      warnings: []
+    };
+  }
+  async #captureBreakpointState() {
+    try {
+      const result = await this.listBreakpoints(true);
+      return result.breakpoints.map((bp) => ({
+        kind: bp.kind,
+        start: bp.start,
+        end: bp.end,
+        enabled: bp.enabled,
+        temporary: bp.temporary,
+        hasCondition: bp.hasCondition,
+        label: this.#breakpointLabels.get(bp.id) ?? null
+      }));
+    } catch (error) {
+      this.#writeProcessLogLine(`[nuclear-reset] failed to capture breakpoints: ${error instanceof Error ? error.message : String(error)}`);
+      return [];
+    }
+  }
+  async #restoreBreakpointState(savedBreakpoints) {
+    if (savedBreakpoints.length === 0) {
+      return;
+    }
+    this.#writeProcessLogLine(`[nuclear-reset] restoring ${savedBreakpoints.length} breakpoints`);
+    for (const bp of savedBreakpoints) {
+      try {
+        await this.breakpointSet({
+          kind: bp.kind,
+          address: bp.start,
+          length: bp.end - bp.start + 1,
+          enabled: bp.enabled,
+          temporary: bp.temporary,
+          label: bp.label ?? void 0
+        });
+        this.#writeProcessLogLine(`[nuclear-reset] restored breakpoint at $${bp.start.toString(16).toUpperCase()}`);
+      } catch (error) {
+        this.#writeProcessLogLine(
+          `[nuclear-reset] failed to restore breakpoint at $${bp.start.toString(16).toUpperCase()}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
   async listBreakpoints(includeDisabled = true) {
     await this.#ensureReady();
     this.#writeProcessLogLine(`[tx] breakpoint_list includeDisabled=${includeDisabled}`);
@@ -2799,7 +2874,9 @@ var ViceSession = class {
         makeWarning(`C64 emulator process exited (${code ?? "null"} / ${signal ?? "null"})`, "process_exit")
       ];
       if (!this.#suppressRecovery && !this.#shuttingDown && this.#config) {
-        void this.#scheduleRecovery();
+        void this.#scheduleRecovery().catch((error) => {
+          this.#writeProcessLogLine(`[recovery-error] ${error instanceof Error ? error.message : String(error)}`);
+        });
       }
     });
     child.once("error", (error) => {
@@ -2812,12 +2889,16 @@ var ViceSession = class {
       this.#transportState = "faulted";
       this.#warnings = [...this.#warnings.filter((warning) => warning.code !== "process_error"), makeWarning(error.message, "process_error")];
       if (!this.#suppressRecovery && !this.#shuttingDown && this.#config) {
-        void this.#scheduleRecovery();
+        void this.#scheduleRecovery().catch((error2) => {
+          this.#writeProcessLogLine(`[recovery-error] ${error2 instanceof Error ? error2.message : String(error2)}`);
+        });
       }
     });
   }
   #attachProcessLogging(child, binary, args) {
     const logStream = (0, import_node_fs.createWriteStream)(VICE_PROCESS_LOG_PATH, { flags: "a" });
+    logStream.on("error", () => {
+    });
     this.#processLogStream = logStream;
     this.#stdoutMirrorBuffer = "";
     this.#stderrMirrorBuffer = "";
@@ -2851,7 +2932,10 @@ var ViceSession = class {
     logStream.write(`
 === Emulator stream closed ${nowIso()} (${reason}) ===
 `);
-    logStream.end();
+    logStream.end(() => {
+    });
+    logStream.on("error", () => {
+    });
     this.#processLogStream = null;
   }
   #mirrorViceOutputChunk(stream, chunk) {
@@ -3633,40 +3717,35 @@ var setRegistersTool = createViceTool({
 });
 var readMemoryTool = createViceTool({
   id: "memory_read",
-  description: "Reads a memory chunk. Use either (address, length) or (start, end) format. Addresses can be decimal (53248) or hex string with prefix ($D000, 0xD000). Returns byte values as decimal numbers.",
-  inputSchema: import_zod4.z.union([
-    import_zod4.z.object({
-      address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      length: import_zod4.z.number().int().positive().max(65535).describe("Number of bytes to read")
-    }).refine((input) => input.address + input.length <= 65536, {
-      message: "address + length must stay within the 64K address space",
-      path: ["length"]
-    }),
-    import_zod4.z.object({
-      start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)")
-    }).refine((input) => input.start <= input.end, {
-      message: "End address must be greater than or equal to start address",
-      path: ["end"]
-    }).refine((input) => input.end < 65536, {
-      message: "End address must stay within the 64K address space",
-      path: ["end"]
-    })
-  ]),
+  description: "Reads a memory chunk. Specify start_address and either data_length or end_address. Address can be decimal (53248) or hex string with prefix ($D000, 0xD000). Returns byte values as decimal numbers.",
+  inputSchema: import_zod4.z.object({
+    start_address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+    data_length: import_zod4.z.number().int().positive().max(65535).optional().describe("Number of bytes to read (use either data_length or end_address)"),
+    end_address: address16Schema.optional().describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000). Use either data_length or end_address.")
+  }),
   dataSchema: import_zod4.z.object({
-    address: import_zod4.z.number().int().min(0).max(65535).describe("Start address of the returned memory chunk"),
+    address: address16Schema.describe("Start address of the returned memory chunk"),
     length: import_zod4.z.number().int().min(0).describe("Number of bytes returned"),
     data: byteArraySchema.describe("Raw bytes returned from memory")
   }),
   execute: async (input) => {
-    let address;
+    const address = input.start_address;
     let length;
-    if ("start" in input && "end" in input) {
-      address = input.start;
-      length = input.end - input.start + 1;
+    if (input.end_address !== void 0) {
+      if (address > input.end_address) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      if (input.end_address >= 65536) {
+        throw new Error("End address must stay within the 64K address space");
+      }
+      length = input.end_address - address + 1;
+    } else if (input.data_length !== void 0) {
+      length = input.data_length;
+      if (address + length > 65536) {
+        throw new Error("address + length must stay within the 64K address space");
+      }
     } else {
-      address = input.address;
-      length = input.length;
+      throw new Error("Must provide either data_length or end_address");
     }
     const result = await c64Session.readMemory(address, address + length - 1);
     return {
@@ -3688,7 +3767,7 @@ var writeMemoryTool = createViceTool({
   }),
   dataSchema: import_zod4.z.object({
     worked: import_zod4.z.boolean().describe("Whether the write operation completed successfully"),
-    address: import_zod4.z.number().int().min(0).max(65535).describe("Start address where the bytes were written"),
+    address: address16Schema.describe("Start address where the bytes were written"),
     length: import_zod4.z.number().int().min(1).describe("Number of bytes written")
   }).extend(debugStateSchema.shape),
   execute: async (input) => await c64Session.writeMemory(input.address, input.data)
@@ -3699,7 +3778,7 @@ var executeTool = createViceTool({
   inputSchema: import_zod4.z.object({
     action: import_zod4.z.enum(["pause", "resume", "step", "step_over", "step_out", "reset"]),
     count: import_zod4.z.number().int().positive().default(1).describe("Instruction count for step and step_over actions"),
-    resetMode: resetModeSchema.default("soft").describe("Reset mode when action is reset"),
+    resetMode: resetModeSchema.default("soft").describe("Reset mode: soft (CPU reset), hard (full machine reset), or nuclear (complete VICE restart)"),
     waitUntilRunningStable: import_zod4.z.boolean().default(false).describe("When action is resume, wait until running becomes stable before returning")
   }),
   dataSchema: debugStateSchema.extend({
@@ -3737,47 +3816,44 @@ var listBreakpointsTool = createViceTool({
 });
 var breakpointSetTool = createViceTool({
   id: "breakpoint_set",
-  description: "Creates an execution breakpoint or read/write watchpoint. Use either (address, length) or (start, end) format. Addresses can be decimal (53248) or hex string with prefix ($D000, 0xD000).",
-  inputSchema: import_zod4.z.union([
-    import_zod4.z.object({
-      kind: breakpointKindSchema,
-      address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      length: import_zod4.z.number().int().positive().default(1).describe("Size of the breakpoint range in bytes"),
-      condition: import_zod4.z.string().optional(),
-      label: import_zod4.z.string().optional(),
-      temporary: import_zod4.z.boolean().default(false),
-      enabled: import_zod4.z.boolean().default(true)
-    }),
-    import_zod4.z.object({
-      kind: breakpointKindSchema,
-      start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      condition: import_zod4.z.string().optional(),
-      label: import_zod4.z.string().optional(),
-      temporary: import_zod4.z.boolean().default(false),
-      enabled: import_zod4.z.boolean().default(true)
-    }).refine((input) => input.start <= input.end, {
-      message: "End address must be greater than or equal to start address",
-      path: ["end"]
-    })
-  ]),
+  description: "Creates an execution breakpoint or read/write watchpoint. Specify start_address and either data_length or end_address. Address can be decimal (53248) or hex string with prefix ($D000, 0xD000).",
+  inputSchema: import_zod4.z.object({
+    kind: breakpointKindSchema,
+    start_address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+    data_length: import_zod4.z.number().int().positive().default(1).describe("Size of the breakpoint range in bytes (use either data_length or end_address)"),
+    end_address: address16Schema.optional().describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000). Use either data_length or end_address."),
+    condition: import_zod4.z.string().optional(),
+    label: import_zod4.z.string().optional(),
+    temporary: import_zod4.z.boolean().default(false),
+    enabled: import_zod4.z.boolean().default(true)
+  }),
   dataSchema: import_zod4.z.object({
     breakpoint: breakpointSchema,
     executionState: executionStateSchema,
     lastStopReason: stopReasonSchema,
-    programCounter: import_zod4.z.number().int().min(0).max(65535).nullable(),
+    programCounter: address16Schema.nullable(),
     registers: c64PartialRegisterValueSchema.nullable()
   }),
   execute: async (input) => {
-    const normalizedInput = "start" in input && "end" in input ? {
+    const address = input.start_address;
+    let length;
+    if (input.end_address !== void 0) {
+      if (address > input.end_address) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      length = input.end_address - address + 1;
+    } else {
+      length = input.data_length;
+    }
+    const normalizedInput = {
       kind: input.kind,
-      address: input.start,
-      length: input.end - input.start + 1,
+      address,
+      length,
       condition: input.condition,
       label: input.label,
       temporary: input.temporary,
       enabled: input.enabled
-    } : input;
+    };
     const result = await c64Session.breakpointSet(normalizedInput);
     return {
       breakpoint: normalizeBreakpoint(result.breakpoint),

package/dist/stdio.js

@@ -40,7 +40,7 @@ var stopReasonSchema = z.enum([
 ]);
 var sessionHealthSchema = z.enum(["not_configured", "starting", "ready", "recovering", "stopped", "error"]);
 var breakpointKindSchema = z.enum(["exec", "read", "write", "read_write"]);
-var resetModeSchema = z.enum(["soft", "hard"]);
+var resetModeSchema = z.enum(["soft", "hard", "nuclear"]);
 var inputActionSchema = z.enum(["press", "release", "tap"]);
 var joystickControlSchema = z.enum(["up", "down", "left", "right", "fire"]);
 var joystickPortSchema = z.union([z.literal(1), z.literal(2)]);
@@ -1702,7 +1702,17 @@ var ViceSession = class {
       }
       this.#syncMonitorRuntimeState();
       if (!this.#suppressRecovery && !this.#shuttingDown && this.#config) {
-        void this.#scheduleRecovery();
+        void this.#scheduleRecovery().catch((error) => {
+          this.#writeProcessLogLine(`[recovery-error] ${error instanceof Error ? error.message : String(error)}`);
+        });
+      }
+    });
+    this.#client.on("transport-error", (error) => {
+      this.#writeProcessLogLine(`[monitor-error] transport error: ${error.message}`);
+      if (!this.#suppressRecovery && !this.#shuttingDown && this.#config) {
+        void this.#scheduleRecovery().catch((recoveryError) => {
+          this.#writeProcessLogLine(`[recovery-error] ${recoveryError instanceof Error ? recoveryError.message : String(recoveryError)}`);
+        });
       }
     });
     this.#client.on("event", (event) => {
@@ -2043,6 +2053,10 @@ var ViceSession = class {
   async resetMachine(mode) {
     return this.#withExecutionLock(async () => {
       await this.#ensureReady();
+      this.#clearHeldInputState();
+      if (mode === "nuclear") {
+        return await this.#performNuclearReset();
+      }
       const wasPaused = this.#explicitPauseActive;
       this.#lastExecutionIntent = "reset";
       this.#writeProcessLogLine(`[tx] execute reset mode=${mode}`);
@@ -2062,6 +2076,67 @@ var ViceSession = class {
       };
     });
   }
+  async #performNuclearReset() {
+    const savedBreakpoints = await this.#captureBreakpointState();
+    const wasPaused = this.#explicitPauseActive;
+    this.#writeProcessLogLine("[nuclear-reset] initiating full VICE process restart");
+    await this.#scheduleRecovery();
+    await this.#restoreBreakpointState(savedBreakpoints);
+    this.#explicitPauseActive = wasPaused;
+    if (wasPaused) {
+      this.#writeProcessLogLine("[nuclear-reset] restoring paused state");
+      await this.pauseExecution();
+    }
+    this.#writeProcessLogLine("[nuclear-reset] completed successfully");
+    const debugState = await this.#readDebugState();
+    return {
+      executionState: debugState.executionState,
+      lastStopReason: debugState.lastStopReason,
+      programCounter: debugState.programCounter,
+      registers: debugState.registers,
+      warnings: []
+    };
+  }
+  async #captureBreakpointState() {
+    try {
+      const result = await this.listBreakpoints(true);
+      return result.breakpoints.map((bp) => ({
+        kind: bp.kind,
+        start: bp.start,
+        end: bp.end,
+        enabled: bp.enabled,
+        temporary: bp.temporary,
+        hasCondition: bp.hasCondition,
+        label: this.#breakpointLabels.get(bp.id) ?? null
+      }));
+    } catch (error) {
+      this.#writeProcessLogLine(`[nuclear-reset] failed to capture breakpoints: ${error instanceof Error ? error.message : String(error)}`);
+      return [];
+    }
+  }
+  async #restoreBreakpointState(savedBreakpoints) {
+    if (savedBreakpoints.length === 0) {
+      return;
+    }
+    this.#writeProcessLogLine(`[nuclear-reset] restoring ${savedBreakpoints.length} breakpoints`);
+    for (const bp of savedBreakpoints) {
+      try {
+        await this.breakpointSet({
+          kind: bp.kind,
+          address: bp.start,
+          length: bp.end - bp.start + 1,
+          enabled: bp.enabled,
+          temporary: bp.temporary,
+          label: bp.label ?? void 0
+        });
+        this.#writeProcessLogLine(`[nuclear-reset] restored breakpoint at $${bp.start.toString(16).toUpperCase()}`);
+      } catch (error) {
+        this.#writeProcessLogLine(
+          `[nuclear-reset] failed to restore breakpoint at $${bp.start.toString(16).toUpperCase()}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
   async listBreakpoints(includeDisabled = true) {
     await this.#ensureReady();
     this.#writeProcessLogLine(`[tx] breakpoint_list includeDisabled=${includeDisabled}`);
@@ -2776,7 +2851,9 @@ var ViceSession = class {
         makeWarning(`C64 emulator process exited (${code ?? "null"} / ${signal ?? "null"})`, "process_exit")
       ];
       if (!this.#suppressRecovery && !this.#shuttingDown && this.#config) {
-        void this.#scheduleRecovery();
+        void this.#scheduleRecovery().catch((error) => {
+          this.#writeProcessLogLine(`[recovery-error] ${error instanceof Error ? error.message : String(error)}`);
+        });
       }
     });
     child.once("error", (error) => {
@@ -2789,12 +2866,16 @@ var ViceSession = class {
       this.#transportState = "faulted";
       this.#warnings = [...this.#warnings.filter((warning) => warning.code !== "process_error"), makeWarning(error.message, "process_error")];
       if (!this.#suppressRecovery && !this.#shuttingDown && this.#config) {
-        void this.#scheduleRecovery();
+        void this.#scheduleRecovery().catch((error2) => {
+          this.#writeProcessLogLine(`[recovery-error] ${error2 instanceof Error ? error2.message : String(error2)}`);
+        });
       }
     });
   }
   #attachProcessLogging(child, binary, args) {
     const logStream = createWriteStream(VICE_PROCESS_LOG_PATH, { flags: "a" });
+    logStream.on("error", () => {
+    });
     this.#processLogStream = logStream;
     this.#stdoutMirrorBuffer = "";
     this.#stderrMirrorBuffer = "";
@@ -2828,7 +2909,10 @@ var ViceSession = class {
     logStream.write(`
 === Emulator stream closed ${nowIso()} (${reason}) ===
 `);
-    logStream.end();
+    logStream.end(() => {
+    });
+    logStream.on("error", () => {
+    });
     this.#processLogStream = null;
   }
   #mirrorViceOutputChunk(stream, chunk) {
@@ -3610,40 +3694,35 @@ var setRegistersTool = createViceTool({
 });
 var readMemoryTool = createViceTool({
   id: "memory_read",
-  description: "Reads a memory chunk. Use either (address, length) or (start, end) format. Addresses can be decimal (53248) or hex string with prefix ($D000, 0xD000). Returns byte values as decimal numbers.",
-  inputSchema: z3.union([
-    z3.object({
-      address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      length: z3.number().int().positive().max(65535).describe("Number of bytes to read")
-    }).refine((input) => input.address + input.length <= 65536, {
-      message: "address + length must stay within the 64K address space",
-      path: ["length"]
-    }),
-    z3.object({
-      start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)")
-    }).refine((input) => input.start <= input.end, {
-      message: "End address must be greater than or equal to start address",
-      path: ["end"]
-    }).refine((input) => input.end < 65536, {
-      message: "End address must stay within the 64K address space",
-      path: ["end"]
-    })
-  ]),
+  description: "Reads a memory chunk. Specify start_address and either data_length or end_address. Address can be decimal (53248) or hex string with prefix ($D000, 0xD000). Returns byte values as decimal numbers.",
+  inputSchema: z3.object({
+    start_address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+    data_length: z3.number().int().positive().max(65535).optional().describe("Number of bytes to read (use either data_length or end_address)"),
+    end_address: address16Schema.optional().describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000). Use either data_length or end_address.")
+  }),
   dataSchema: z3.object({
-    address: z3.number().int().min(0).max(65535).describe("Start address of the returned memory chunk"),
+    address: address16Schema.describe("Start address of the returned memory chunk"),
     length: z3.number().int().min(0).describe("Number of bytes returned"),
     data: byteArraySchema.describe("Raw bytes returned from memory")
   }),
   execute: async (input) => {
-    let address;
+    const address = input.start_address;
     let length;
-    if ("start" in input && "end" in input) {
-      address = input.start;
-      length = input.end - input.start + 1;
+    if (input.end_address !== void 0) {
+      if (address > input.end_address) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      if (input.end_address >= 65536) {
+        throw new Error("End address must stay within the 64K address space");
+      }
+      length = input.end_address - address + 1;
+    } else if (input.data_length !== void 0) {
+      length = input.data_length;
+      if (address + length > 65536) {
+        throw new Error("address + length must stay within the 64K address space");
+      }
     } else {
-      address = input.address;
-      length = input.length;
+      throw new Error("Must provide either data_length or end_address");
     }
     const result = await c64Session.readMemory(address, address + length - 1);
     return {
@@ -3665,7 +3744,7 @@ var writeMemoryTool = createViceTool({
   }),
   dataSchema: z3.object({
     worked: z3.boolean().describe("Whether the write operation completed successfully"),
-    address: z3.number().int().min(0).max(65535).describe("Start address where the bytes were written"),
+    address: address16Schema.describe("Start address where the bytes were written"),
     length: z3.number().int().min(1).describe("Number of bytes written")
   }).extend(debugStateSchema.shape),
   execute: async (input) => await c64Session.writeMemory(input.address, input.data)
@@ -3676,7 +3755,7 @@ var executeTool = createViceTool({
   inputSchema: z3.object({
     action: z3.enum(["pause", "resume", "step", "step_over", "step_out", "reset"]),
     count: z3.number().int().positive().default(1).describe("Instruction count for step and step_over actions"),
-    resetMode: resetModeSchema.default("soft").describe("Reset mode when action is reset"),
+    resetMode: resetModeSchema.default("soft").describe("Reset mode: soft (CPU reset), hard (full machine reset), or nuclear (complete VICE restart)"),
     waitUntilRunningStable: z3.boolean().default(false).describe("When action is resume, wait until running becomes stable before returning")
   }),
   dataSchema: debugStateSchema.extend({
@@ -3714,47 +3793,44 @@ var listBreakpointsTool = createViceTool({
 });
 var breakpointSetTool = createViceTool({
   id: "breakpoint_set",
-  description: "Creates an execution breakpoint or read/write watchpoint. Use either (address, length) or (start, end) format. Addresses can be decimal (53248) or hex string with prefix ($D000, 0xD000).",
-  inputSchema: z3.union([
-    z3.object({
-      kind: breakpointKindSchema,
-      address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      length: z3.number().int().positive().default(1).describe("Size of the breakpoint range in bytes"),
-      condition: z3.string().optional(),
-      label: z3.string().optional(),
-      temporary: z3.boolean().default(false),
-      enabled: z3.boolean().default(true)
-    }),
-    z3.object({
-      kind: breakpointKindSchema,
-      start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      condition: z3.string().optional(),
-      label: z3.string().optional(),
-      temporary: z3.boolean().default(false),
-      enabled: z3.boolean().default(true)
-    }).refine((input) => input.start <= input.end, {
-      message: "End address must be greater than or equal to start address",
-      path: ["end"]
-    })
-  ]),
+  description: "Creates an execution breakpoint or read/write watchpoint. Specify start_address and either data_length or end_address. Address can be decimal (53248) or hex string with prefix ($D000, 0xD000).",
+  inputSchema: z3.object({
+    kind: breakpointKindSchema,
+    start_address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+    data_length: z3.number().int().positive().default(1).describe("Size of the breakpoint range in bytes (use either data_length or end_address)"),
+    end_address: address16Schema.optional().describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000). Use either data_length or end_address."),
+    condition: z3.string().optional(),
+    label: z3.string().optional(),
+    temporary: z3.boolean().default(false),
+    enabled: z3.boolean().default(true)
+  }),
   dataSchema: z3.object({
     breakpoint: breakpointSchema,
     executionState: executionStateSchema,
     lastStopReason: stopReasonSchema,
-    programCounter: z3.number().int().min(0).max(65535).nullable(),
+    programCounter: address16Schema.nullable(),
     registers: c64PartialRegisterValueSchema.nullable()
   }),
   execute: async (input) => {
-    const normalizedInput = "start" in input && "end" in input ? {
+    const address = input.start_address;
+    let length;
+    if (input.end_address !== void 0) {
+      if (address > input.end_address) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      length = input.end_address - address + 1;
+    } else {
+      length = input.data_length;
+    }
+    const normalizedInput = {
       kind: input.kind,
-      address: input.start,
-      length: input.end - input.start + 1,
+      address,
+      length,
       condition: input.condition,
       label: input.label,
       temporary: input.temporary,
       enabled: input.enabled
-    } : input;
+    };
     const result = await c64Session.breakpointSet(normalizedInput);
     return {
       breakpoint: normalizeBreakpoint(result.breakpoint),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c64-debug-mcp",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "Model Context Protocol server for C64 debugging via VICE emulator",
   "type": "module",
   "keywords": [