c64bridge 0.7.4 → 0.8.1

package/mcp/tools.json

@@ -0,0 +1,4517 @@
+{
+  "tools": [
+    {
+      "name": "c64_program",
+      "title": "Runs PRG/CRT files, uploads BASIC or ASM, and coordinates batch test flows.",
+      "description": "Grouped entry point for program upload, execution, and batch workflows.",
+      "inputSchema": {
+        "type": "object",
+        "description": "Program operations available via the c64_program tool.",
+        "oneOf": [
+          {
+            "type": "object",
+            "description": "Load a PRG from Ultimate storage without executing it.",
+            "properties": {
+              "path": {
+                "type": "string",
+                "description": "Path to the PRG image. Use an Ultimate-visible filesystem path on c64u, or a host-local filesystem path on VICE.",
+                "minLength": 1
+              },
+              "op": {
+                "const": "load_prg"
+              }
+            },
+            "required": [
+              "path",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Load and execute a PRG from Ultimate-visible storage on c64u or a host-local path on VICE.",
+            "properties": {
+              "path": {
+                "type": "string",
+                "description": "Path to the PRG image. Use an Ultimate-visible filesystem path on c64u, or a host-local filesystem path on VICE.",
+                "minLength": 1
+              },
+              "op": {
+                "const": "run_prg"
+              }
+            },
+            "required": [
+              "path",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Mount and run a CRT cartridge image.",
+            "properties": {
+              "path": {
+                "type": "string",
+                "description": "Path to the CRT image on Ultimate-visible storage. CRT mounting is only supported on c64u.",
+                "minLength": 1
+              },
+              "op": {
+                "const": "run_crt"
+              }
+            },
+            "required": [
+              "path",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Upload Commodore BASIC v2 source and execute it immediately.",
+            "properties": {
+              "program": {
+                "type": "string",
+                "description": "Commodore BASIC v2 program source to upload and run.",
+                "minLength": 1
+              },
+              "verify": {
+                "type": "boolean",
+                "description": "Run post-execution polling to ensure the BASIC program executed without errors.",
+                "default": false
+              },
+              "op": {
+                "const": "upload_run_basic"
+              }
+            },
+            "required": [
+              "program",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Assemble 6502/6510 source, upload the PRG, and execute it.",
+            "properties": {
+              "program": {
+                "type": "string",
+                "description": "Assembly source that will be assembled to a PRG and executed.",
+                "minLength": 1
+              },
+              "verify": {
+                "type": "boolean",
+                "description": "Run post-execution polling to confirm the assembly program remained stable.",
+                "default": false
+              },
+              "op": {
+                "const": "upload_run_asm"
+              }
+            },
+            "required": [
+              "program",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Run multiple PRG/CRT programs with post-run assertions.",
+            "properties": {
+              "programs": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "description": "Program to run with assertions",
+                  "properties": {
+                    "path": {
+                      "type": "string",
+                      "description": "Program path (PRG or CRT)",
+                      "minLength": 1
+                    },
+                    "assertions": {
+                      "type": [
+                        "array",
+                        "null"
+                      ],
+                      "items": {
+                        "type": "object",
+                        "description": "Assertion to check after run",
+                        "properties": {
+                          "type": {
+                            "type": "string",
+                            "description": "Assertion type",
+                            "enum": [
+                              "screen_contains",
+                              "memory_equals",
+                              "sid_silent"
+                            ]
+                          },
+                          "pattern": {
+                            "type": [
+                              "string",
+                              "null"
+                            ],
+                            "description": "Pattern for screen_contains",
+                            "minLength": 1
+                          },
+                          "address": {
+                            "type": [
+                              "string",
+                              "null"
+                            ],
+                            "description": "Address for memory_equals",
+                            "minLength": 1
+                          },
+                          "expected": {
+                            "type": [
+                              "string",
+                              "null"
+                            ],
+                            "description": "Expected value (hex)",
+                            "minLength": 1
+                          }
+                        },
+                        "required": [
+                          "type"
+                        ],
+                        "additionalProperties": false
+                      }
+                    }
+                  },
+                  "required": [
+                    "path"
+                  ],
+                  "additionalProperties": false
+                }
+              },
+              "continueOnError": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Continue running programs after assertion failure",
+                "default": false
+              },
+              "durationMs": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Duration to run each program before assertions",
+                "minimum": 1,
+                "default": 2000
+              },
+              "outputPath": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Output directory for test results",
+                "minLength": 1
+              },
+              "resetDelayMs": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Delay after reset operations to allow the platform to settle.",
+                "minimum": 0,
+                "maximum": 1000,
+                "default": 100
+              },
+              "op": {
+                "const": "batch_run"
+              }
+            },
+            "required": [
+              "programs",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Capture screen, memory, and debug registers into an artifact bundle.",
+            "properties": {
+              "runId": {
+                "type": "string",
+                "description": "Unique identifier for this run",
+                "minLength": 1
+              },
+              "outputPath": {
+                "type": "string",
+                "description": "Output directory for artifacts bundle",
+                "minLength": 1
+              },
+              "captureScreen": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Capture screen content",
+                "default": true
+              },
+              "memoryRanges": {
+                "type": [
+                  "array",
+                  "null"
+                ],
+                "items": {
+                  "type": "object",
+                  "description": "Memory range to snapshot",
+                  "properties": {
+                    "address": {
+                      "type": "string",
+                      "description": "Start address",
+                      "minLength": 1
+                    },
+                    "length": {
+                      "type": "integer",
+                      "description": "Length in bytes",
+                      "minimum": 1
+                    }
+                  },
+                  "required": [
+                    "address",
+                    "length"
+                  ],
+                  "additionalProperties": false
+                }
+              },
+              "captureDebugReg": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Capture debugreg state",
+                "default": true
+              },
+              "op": {
+                "const": "bundle_run"
+              }
+            },
+            "required": [
+              "runId",
+              "outputPath",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Show a platform-customized greeting on one or more configured backends, capture screenshots, and verify the results.",
+            "properties": {
+              "platforms": {
+                "type": [
+                  "array",
+                  "null"
+                ],
+                "items": {
+                  "type": "string",
+                  "description": "Backends to target in sequence.",
+                  "minLength": 1,
+                  "enum": [
+                    "vice",
+                    "c64u"
+                  ]
+                },
+                "default": [
+                  "vice",
+                  "c64u"
+                ]
+              },
+              "messageTemplate": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Greeting template. Use {PLATFORM}/{BACKEND} for uppercase or {platform}/{backend} for lowercase substitution.",
+                "minLength": 1,
+                "default": "HAVE A GREAT DAY, {PLATFORM}!"
+              },
+              "verify": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Poll the text screen and require the rendered greeting to appear.",
+                "default": true
+              },
+              "captureScreenshot": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Capture a framebuffer screenshot and save it as a PNG per backend.",
+                "default": true
+              },
+              "outputPath": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Directory for screenshots and the workflow summary JSON.",
+                "minLength": 1
+              },
+              "restoreActiveBackend": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Restore the backend that was active before the workflow started.",
+                "default": true
+              },
+              "timeoutMs": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Maximum time to wait for each greeting to appear on screen.",
+                "minimum": 100,
+                "maximum": 5000,
+                "default": 1500
+              },
+              "pollIntervalMs": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Delay between screen polls while verifying the greeting.",
+                "minimum": 50,
+                "maximum": 1000,
+                "default": 100
+              },
+              "op": {
+                "const": "cross_platform_greeting"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          }
+        ],
+        "discriminator": {
+          "propertyName": "op"
+        }
+      },
+      "_meta": {
+        "domain": "programs",
+        "summary": "Runs PRG/CRT files, uploads BASIC or ASM, and coordinates batch test flows.",
+        "lifecycle": "request-response",
+        "resources": [
+          "c64://context/bootstrap",
+          "c64://specs/basic",
+          "c64://specs/assembly"
+        ],
+        "prompts": [
+          "basic-program",
+          "assembly-program"
+        ],
+        "examples": [
+          {
+            "name": "Run PRG from storage",
+            "description": "Load and execute a PRG in one call",
+            "arguments": {
+              "op": "run_prg",
+              "path": "//USB0/demo.prg"
+            }
+          },
+          {
+            "name": "Upload BASIC source",
+            "description": "Send inline BASIC to the C64 and run it",
+            "arguments": {
+              "op": "upload_run_basic",
+              "program": "10 PRINT \"HELLO\"\n20 GOTO 10"
+            }
+          },
+          {
+            "name": "Show greeting on both backends",
+            "description": "Render a platform-specific greeting on VICE and C64U with screenshot verification",
+            "arguments": {
+              "op": "cross_platform_greeting"
+            }
+          }
+        ],
+        "tags": [
+          "programs",
+          "execution",
+          "grouped"
+        ],
+        "workflowHints": [
+          "Choose BASIC or assembly uploaders based on the language you just generated for the user.",
+          "Prefer PRG or CRT runners when the user supplies a file path instead of source text; PRG paths are host-local on VICE and Ultimate-visible on c64u.",
+          "For a quick visible confirmation on VICE and/or C64U, prefer cross_platform_greeting instead of composing manual backend switches and BASIC upload steps."
+        ],
+        "platforms": [
+          "c64u",
+          "vice"
+        ],
+        "operationPlatforms": {
+          "load_prg": [
+            "c64u"
+          ],
+          "run_crt": [
+            "c64u"
+          ],
+          "bundle_run": [
+            "c64u"
+          ]
+        }
+      }
+    },
+    {
+      "name": "c64_memory",
+      "title": "Reads or writes RAM, captures the screen, or waits for text matches in one tool.",
+      "description": "Grouped entry point for memory I/O, screen reads, and screen polling.",
+      "inputSchema": {
+        "type": "object",
+        "description": "Memory operations available via the c64_memory tool.",
+        "oneOf": [
+          {
+            "type": "object",
+            "description": "Read a range of bytes and return a hex dump with address metadata.",
+            "properties": {
+              "address": {
+                "type": "string",
+                "description": "Start address expressed as $HHHH, decimal, or a documented symbol name.",
+                "minLength": 1
+              },
+              "length": {
+                "type": "integer",
+                "description": "Number of bytes to read starting from the resolved address.",
+                "minimum": 1,
+                "maximum": 4096,
+                "default": 256
+              },
+              "op": {
+                "const": "read"
+              }
+            },
+            "required": [
+              "address",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Write a hexadecimal byte sequence into RAM.",
+            "properties": {
+              "address": {
+                "type": "string",
+                "description": "Destination address expressed as $HHHH, decimal, or a documented symbol name.",
+                "minLength": 1
+              },
+              "bytes": {
+                "type": "string",
+                "description": "Hex byte sequence like $AABBCC or AA BB CC to write starting at the resolved address.",
+                "minLength": 2,
+                "pattern": "^[\\s_0-9A-Fa-f$]+$"
+              },
+              "verify": {
+                "type": "boolean",
+                "description": "When true, verify the write by reading before and after the change; Ultimate hardware also pauses during verification.",
+                "default": false
+              },
+              "expected": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Optional hex data expected before the write (verifies before writing).",
+                "minLength": 2,
+                "pattern": "^[\\s_0-9A-Fa-f$]+$"
+              },
+              "mask": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Optional verification mask (hex); only bits set in the mask are compared.",
+                "minLength": 2,
+                "pattern": "^[\\s_0-9A-Fa-f$]+$"
+              },
+              "abortOnMismatch": {
+                "type": "boolean",
+                "description": "Abort the write when the pre-write verification fails.",
+                "default": true
+              },
+              "op": {
+                "const": "write"
+              }
+            },
+            "required": [
+              "address",
+              "bytes",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Return the current 40x25 text screen converted to ASCII.",
+            "properties": {
+              "op": {
+                "const": "read_screen"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Poll the screen until a substring or regex appears, or timeout elapses.",
+            "properties": {
+              "pattern": {
+                "type": "string",
+                "description": "Substring or regex to find",
+                "minLength": 1
+              },
+              "isRegex": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Interpret pattern as regular expression",
+                "default": false
+              },
+              "caseInsensitive": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Case-insensitive search",
+                "default": true
+              },
+              "timeoutMs": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Overall timeout in milliseconds",
+                "minimum": 1,
+                "default": 3000
+              },
+              "intervalMs": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Poll interval in milliseconds",
+                "minimum": 1,
+                "default": 100
+              },
+              "op": {
+                "const": "wait_for_text"
+              }
+            },
+            "required": [
+              "pattern",
+              "op"
+            ],
+            "additionalProperties": false
+          }
+        ],
+        "discriminator": {
+          "propertyName": "op"
+        }
+      },
+      "_meta": {
+        "domain": "memory",
+        "summary": "Reads or writes RAM, captures the screen, or waits for text matches in one tool.",
+        "lifecycle": "request-response",
+        "resources": [
+          "c64://context/bootstrap",
+          "c64://specs/basic",
+          "c64://specs/assembly"
+        ],
+        "prompts": [
+          "memory-debug",
+          "basic-program",
+          "assembly-program"
+        ],
+        "examples": [
+          {
+            "name": "Read colour RAM",
+            "description": "Read 16 bytes starting at $D800",
+            "arguments": {
+              "op": "read",
+              "address": "$D800",
+              "length": 16
+            }
+          },
+          {
+            "name": "Wait for READY prompt",
+            "description": "Poll until the READY. prompt appears",
+            "arguments": {
+              "op": "wait_for_text",
+              "pattern": "READY."
+            }
+          }
+        ],
+        "tags": [
+          "memory",
+          "debug",
+          "screen",
+          "grouped"
+        ],
+        "workflowHints": [
+          "Pair memory operations with documentation snippets so addresses and symbols stay meaningful to the user.",
+          "Confirm intent before mutating RAM and explain how the change affects the running program."
+        ],
+        "platforms": [
+          "c64u",
+          "vice"
+        ]
+      }
+    },
+    {
+      "name": "c64_sound",
+      "title": "Adjusts SID registers, plays files, composes music, and runs verification captures.",
+      "description": "Grouped entry point for SID control, playback, composition, and analysis workflows.",
+      "inputSchema": {
+        "type": "object",
+        "description": "Sound operations available via the c64_sound tool.",
+        "oneOf": [
+          {
+            "type": "object",
+            "description": "Capture raw stereo PCM samples from the C64 Ultimate audio UDP stream.",
+            "properties": {
+              "op": {
+                "const": "capture_samples"
+              },
+              "count": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Number of stereo sample pairs to capture.",
+                "minimum": 1,
+                "maximum": 65536,
+                "default": 256
+              },
+              "encoding": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Encoding used for the PCM sample payload.",
+                "enum": [
+                  "base64",
+                  "hex"
+                ],
+                "default": "base64"
+              }
+            },
+            "required": [
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Set the SID master volume register at $D418 (0-15).",
+            "properties": {
+              "volume": {
+                "type": "number",
+                "description": "Desired SID master volume. Values outside 0-15 are clamped.",
+                "minimum": 0,
+                "maximum": 15
+              },
+              "op": {
+                "const": "set_volume"
+              }
+            },
+            "required": [
+              "volume",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Soft or hard reset of SID registers to clear glitches.",
+            "properties": {
+              "hard": {
+                "type": "boolean",
+                "description": "If true, perform a hard register scrub; otherwise silence voices softly.",
+                "default": false
+              },
+              "op": {
+                "const": "reset"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Trigger a SID voice with configurable waveform, ADSR, and pitch.",
+            "properties": {
+              "voice": {
+                "type": "integer",
+                "description": "SID voice to trigger (1-3).",
+                "minimum": 1,
+                "maximum": 3,
+                "default": 1
+              },
+              "note": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Musical note like A4, C#5, or Bb3. Overrides frequencyHz if provided.",
+                "pattern": "^([A-Ga-g])([#b]?)(-?\\d+)$"
+              },
+              "frequencyHz": {
+                "type": [
+                  "number",
+                  "null"
+                ],
+                "description": "Explicit frequency in Hz. Used when note is omitted.",
+                "minimum": 1
+              },
+              "system": {
+                "type": "string",
+                "description": "Video system for frequency calculation.",
+                "enum": [
+                  "PAL",
+                  "NTSC"
+                ],
+                "default": "PAL"
+              },
+              "waveform": {
+                "type": "string",
+                "description": "SID waveform to enable.",
+                "enum": [
+                  "pulse",
+                  "saw",
+                  "tri",
+                  "noise"
+                ],
+                "default": "pulse"
+              },
+              "pulseWidth": {
+                "type": "integer",
+                "description": "Pulse width (0-4095). Used for pulse waveform.",
+                "minimum": 0,
+                "maximum": 4095,
+                "default": 2048
+              },
+              "attack": {
+                "type": "integer",
+                "description": "Attack rate nibble (0-15).",
+                "minimum": 0,
+                "maximum": 15,
+                "default": 1
+              },
+              "decay": {
+                "type": "integer",
+                "description": "Decay rate nibble (0-15).",
+                "minimum": 0,
+                "maximum": 15,
+                "default": 1
+              },
+              "sustain": {
+                "type": "integer",
+                "description": "Sustain level nibble (0-15).",
+                "minimum": 0,
+                "maximum": 15,
+                "default": 15
+              },
+              "release": {
+                "type": "integer",
+                "description": "Release rate nibble (0-15).",
+                "minimum": 0,
+                "maximum": 15,
+                "default": 3
+              },
+              "op": {
+                "const": "note_on"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Release a SID voice by clearing its gate bit.",
+            "properties": {
+              "voice": {
+                "type": "integer",
+                "description": "SID voice to release (1-3).",
+                "minimum": 1,
+                "maximum": 3
+              },
+              "op": {
+                "const": "note_off"
+              }
+            },
+            "required": [
+              "voice",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Silence all SID voices with optional audio verification.",
+            "properties": {
+              "verify": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "When true, record audio after silencing to confirm the SID output is quiet.",
+                "default": false
+              },
+              "op": {
+                "const": "silence_all"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Play a SID file stored on the Ultimate filesystem.",
+            "properties": {
+              "path": {
+                "type": "string",
+                "description": "Absolute or Ultimate filesystem path to the SID, PRG, or audio file.",
+                "minLength": 1
+              },
+              "songnr": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Song number within the SID file (0-based index).",
+                "minimum": 0
+              },
+              "op": {
+                "const": "play_sid_file"
+              }
+            },
+            "required": [
+              "path",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Play a MOD tracker module via the Ultimate SID player.",
+            "properties": {
+              "path": {
+                "type": "string",
+                "description": "Absolute or Ultimate filesystem path to the SID, PRG, or audio file.",
+                "minLength": 1
+              },
+              "op": {
+                "const": "play_mod_file"
+              }
+            },
+            "required": [
+              "path",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Generate a lightweight SID arpeggio playback sequence.",
+            "properties": {
+              "root": {
+                "type": "string",
+                "description": "Root note for the arpeggio such as C4 or A#3.",
+                "pattern": "^([A-Ga-g])([#b]?)(-?\\d+)$",
+                "default": "C4"
+              },
+              "pattern": {
+                "type": "string",
+                "description": "Comma-separated semitone offsets (e.g. '0,4,7').",
+                "minLength": 1,
+                "default": "0,4,7"
+              },
+              "steps": {
+                "type": "integer",
+                "description": "Number of notes to schedule.",
+                "minimum": 1,
+                "maximum": 128,
+                "default": 16
+              },
+              "tempoMs": {
+                "type": "integer",
+                "description": "Delay in milliseconds between notes.",
+                "minimum": 20,
+                "maximum": 2000,
+                "default": 120
+              },
+              "waveform": {
+                "type": "string",
+                "description": "Waveform for playback.",
+                "enum": [
+                  "pulse",
+                  "saw",
+                  "tri",
+                  "noise"
+                ],
+                "default": "tri"
+              },
+              "preset": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Optional musical preset to influence timing/expression.",
+                "enum": [
+                  "classic",
+                  "expression"
+                ],
+                "default": "classic"
+              },
+              "op": {
+                "const": "generate"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Compile SIDWAVE or CPG source and optionally play it immediately.",
+            "properties": {
+              "sidwave": {
+                "description": "SIDWAVE composition represented as YAML/JSON text or an already parsed object.",
+                "type": [
+                  "string",
+                  "object",
+                  "null"
+                ]
+              },
+              "cpg": {
+                "description": "SIDWAVE composition represented as YAML/JSON text or an already parsed object.",
+                "type": [
+                  "string",
+                  "object",
+                  "null"
+                ]
+              },
+              "format": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Source format hint when providing raw text.",
+                "enum": [
+                  "yaml",
+                  "json"
+                ]
+              },
+              "output": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Playback target format.",
+                "enum": [
+                  "prg",
+                  "sid"
+                ],
+                "default": "prg"
+              },
+              "dryRun": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "When true, skip playback and only return compilation metadata.",
+                "default": false
+              },
+              "op": {
+                "const": "compile_play"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Compile and play a built-in SID preset such as Für Elise by Beethoven.",
+            "properties": {
+              "preset": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Named SID preset to compile and play. Canonical public preset: fuer_elise.",
+                "minLength": 1,
+                "default": "fuer_elise"
+              },
+              "platforms": {
+                "type": [
+                  "array",
+                  "null"
+                ],
+                "items": {
+                  "type": "string",
+                  "description": "Backends to target in sequence.",
+                  "minLength": 1,
+                  "enum": [
+                    "vice",
+                    "c64u"
+                  ]
+                }
+              },
+              "verify": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Capture and analyze audio on supported backends after playback starts.",
+                "default": true
+              },
+              "analysisDurationSeconds": {
+                "type": [
+                  "number",
+                  "null"
+                ],
+                "description": "Length of the verification recording on analyzable backends.",
+                "minimum": 0.5,
+                "maximum": 20,
+                "default": 4
+              },
+              "waitBeforeCaptureMs": {
+                "type": [
+                  "number",
+                  "null"
+                ],
+                "description": "Delay between starting playback and beginning verification capture.",
+                "minimum": 0,
+                "maximum": 5000,
+                "default": 400
+              },
+              "restoreActiveBackend": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Restore the backend that was active before the workflow started.",
+                "default": true
+              },
+              "op": {
+                "const": "play_preset"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Compile a SIDWAVE score, play it, and analyze the recording.",
+            "properties": {
+              "sidwave": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "SIDWAVE source in YAML or JSON format.",
+                "minLength": 1
+              },
+              "cpg": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Legacy CPG input format.",
+                "minLength": 1
+              },
+              "output": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Playback artifact format.",
+                "enum": [
+                  "prg",
+                  "sid"
+                ],
+                "default": "prg"
+              },
+              "waitBeforeCaptureMs": {
+                "type": [
+                  "number",
+                  "null"
+                ],
+                "description": "Delay between starting playback and beginning analysis capture (milliseconds).",
+                "minimum": 0,
+                "maximum": 5000,
+                "default": 500
+              },
+              "analysisDurationSeconds": {
+                "type": [
+                  "number",
+                  "null"
+                ],
+                "description": "Audio capture length in seconds.",
+                "minimum": 0.5,
+                "maximum": 20,
+                "default": 3
+              },
+              "expectedSidwave": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Optional expected SIDWAVE used to refine analysis comparisons.",
+                "minLength": 1
+              },
+              "verifySilenceBefore": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Run silence verification before playback to ensure a quiet baseline.",
+                "default": true
+              },
+              "verifySilenceAfter": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Run silence verification after playback to ensure voices are released.",
+                "default": true
+              },
+              "silenceDurationSeconds": {
+                "type": [
+                  "number",
+                  "null"
+                ],
+                "description": "Audio capture length used for silence verification.",
+                "minimum": 0.5,
+                "maximum": 10,
+                "default": 1.5
+              },
+              "silenceRmsThreshold": {
+                "type": [
+                  "number",
+                  "null"
+                ],
+                "description": "RMS threshold applied to silence verification captures.",
+                "minimum": 0,
+                "maximum": 1,
+                "default": 0.02
+              },
+              "postSilenceWaitMs": {
+                "type": [
+                  "number",
+                  "null"
+                ],
+                "description": "Delay between main analysis capture and the post-playback silence check (milliseconds).",
+                "minimum": 0,
+                "maximum": 5000,
+                "default": 200
+              },
+              "silenceWaitMs": {
+                "type": [
+                  "number",
+                  "null"
+                ],
+                "description": "Delay between silencing the SID and recording during pre/post checks (milliseconds).",
+                "minimum": 0,
+                "maximum": 5000,
+                "default": 150
+              },
+              "op": {
+                "const": "pipeline"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Automatically analyze SID playback when verification is requested.",
+            "properties": {
+              "request": {
+                "type": "string",
+                "description": "Natural language user request describing the verification goal.",
+                "minLength": 1
+              },
+              "durationSeconds": {
+                "type": [
+                  "number",
+                  "null"
+                ],
+                "description": "Override capture duration in seconds.",
+                "minimum": 0.5,
+                "maximum": 30
+              },
+              "expectedSidwave": {
+                "description": "SIDWAVE composition represented as YAML/JSON text or an already parsed object.",
+                "type": [
+                  "string",
+                  "object",
+                  "null"
+                ]
+              },
+              "op": {
+                "const": "analyze"
+              }
+            },
+            "required": [
+              "request",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Record audio for a fixed duration and return SID analysis metrics.",
+            "properties": {
+              "durationSeconds": {
+                "type": "number",
+                "description": "Capture duration in seconds (0.5 - 30).",
+                "minimum": 0.5,
+                "maximum": 30
+              },
+              "expectedSidwave": {
+                "description": "SIDWAVE composition represented as YAML/JSON text or an already parsed object.",
+                "type": [
+                  "string",
+                  "object",
+                  "null"
+                ]
+              },
+              "op": {
+                "const": "record_analyze"
+              }
+            },
+            "required": [
+              "durationSeconds",
+              "op"
+            ],
+            "additionalProperties": false
+          }
+        ],
+        "discriminator": {
+          "propertyName": "op"
+        }
+      },
+      "_meta": {
+        "domain": "audio",
+        "summary": "Adjusts SID registers, plays files, composes music, and runs verification captures.",
+        "lifecycle": "request-response",
+        "resources": [
+          "c64://specs/sid",
+          "c64://specs/sidwave",
+          "c64://docs/sid/file-structure"
+        ],
+        "prompts": [
+          "sid-music"
+        ],
+        "examples": [
+          {
+            "name": "Capture samples",
+            "description": "Grab 256 stereo sample pairs from the Ultimate audio stream",
+            "arguments": {
+              "op": "capture_samples"
+            }
+          },
+          {
+            "name": "Trigger SID voice",
+            "description": "Start voice 1 on C4 with a triangle waveform",
+            "arguments": {
+              "op": "note_on",
+              "voice": 1,
+              "note": "C4",
+              "waveform": "tri"
+            }
+          },
+          {
+            "name": "Play Für Elise",
+            "description": "Compile and play the built-in Für Elise preset on the active backend",
+            "arguments": {
+              "op": "play_preset",
+              "preset": "fuer_elise"
+            }
+          },
+          {
+            "name": "Verify silence",
+            "description": "Stop all voices and confirm the SID output is quiet",
+            "arguments": {
+              "op": "silence_all",
+              "verify": true
+            }
+          }
+        ],
+        "tags": [
+          "sid",
+          "audio",
+          "grouped"
+        ],
+        "workflowHints": [
+          "Trigger note_on or generate when the user wants immediate SID playback.",
+          "Follow up playback changes with analyze or silence verification to provide confident audio feedback."
+        ],
+        "platforms": [
+          "c64u",
+          "vice"
+        ],
+        "operationPlatforms": {
+          "capture_samples": [
+            "c64u"
+          ],
+          "play_sid_file": [
+            "c64u"
+          ],
+          "play_mod_file": [
+            "c64u"
+          ],
+          "pipeline": [
+            "c64u"
+          ],
+          "analyze": [
+            "c64u"
+          ],
+          "record_analyze": [
+            "c64u"
+          ]
+        }
+      }
+    },
+    {
+      "name": "c64_system",
+      "title": "Manages machine state (pause, reset, power) and schedules recurring background tasks.",
+      "description": "Grouped entry point for power, reset, menu, and background task control.",
+      "inputSchema": {
+        "type": "object",
+        "description": "System operations available via the c64_system tool.",
+        "oneOf": [
+          {
+            "type": "object",
+            "description": "Pause the machine until resumed.",
+            "properties": {
+              "op": {
+                "const": "pause"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Resume CPU execution after a pause.",
+            "properties": {
+              "op": {
+                "const": "resume"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Issue a soft reset without cutting power.",
+            "properties": {
+              "op": {
+                "const": "reset"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Trigger a firmware reboot to recover from faults.",
+            "properties": {
+              "op": {
+                "const": "reboot"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Request a controlled shutdown via the Ultimate firmware.",
+            "properties": {
+              "op": {
+                "const": "poweroff"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Toggle the Ultimate menu button for navigation.",
+            "properties": {
+              "op": {
+                "const": "menu"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Start a named background task that runs on an interval.",
+            "properties": {
+              "name": {
+                "type": "string",
+                "description": "Unique task name",
+                "minLength": 1
+              },
+              "operation": {
+                "type": "string",
+                "description": "Operation name (e.g., read, read_screen)",
+                "minLength": 1
+              },
+              "arguments": {
+                "type": [
+                  "object",
+                  "null"
+                ],
+                "description": "Operation-specific arguments",
+                "properties": {},
+                "additionalProperties": true,
+                "default": {}
+              },
+              "intervalMs": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Interval milliseconds",
+                "minimum": 1,
+                "default": 1000
+              },
+              "maxIterations": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Maximum number of iterations (omit for indefinite)",
+                "minimum": 1
+              },
+              "op": {
+                "const": "start_task"
+              }
+            },
+            "required": [
+              "name",
+              "operation",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Stop a specific background task and clear its timer.",
+            "properties": {
+              "name": {
+                "type": "string",
+                "description": "Task name",
+                "minLength": 1
+              },
+              "op": {
+                "const": "stop_task"
+              }
+            },
+            "required": [
+              "name",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Stop every running background task and persist state.",
+            "properties": {
+              "op": {
+                "const": "stop_all_tasks"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "List known background tasks with status metadata.",
+            "properties": {
+              "op": {
+                "const": "list_tasks"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Summarize diagnostics spans and tool latencies from the current or latest MCP session.",
+            "properties": {
+              "scope": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Which diagnostics session to summarize.",
+                "enum": [
+                  "current",
+                  "latest"
+                ],
+                "default": "current"
+              },
+              "includeTimeline": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Include the tail of the event timeline.",
+                "default": true
+              },
+              "maxEntries": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Maximum number of span and timeline entries to return.",
+                "minimum": 1,
+                "maximum": 200,
+                "default": 25
+              },
+              "op": {
+                "const": "performance_report"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          }
+        ],
+        "discriminator": {
+          "propertyName": "op"
+        }
+      },
+      "_meta": {
+        "domain": "system",
+        "summary": "Manages machine state (pause, reset, power) and schedules recurring background tasks.",
+        "lifecycle": "request-response",
+        "resources": [
+          "c64://context/bootstrap"
+        ],
+        "prompts": [
+          "memory-debug"
+        ],
+        "examples": [
+          {
+            "name": "Soft reset",
+            "description": "Issue a soft reset without cutting power",
+            "arguments": {
+              "op": "reset"
+            }
+          },
+          {
+            "name": "Start background screen capture",
+            "description": "Launch a recurring read_screen task",
+            "arguments": {
+              "op": "start_task",
+              "name": "screen_poll",
+              "operation": "read_screen",
+              "intervalMs": 2000
+            }
+          },
+          {
+            "name": "Inspect performance trace",
+            "description": "Summarize the current session diagnostics for profiling",
+            "arguments": {
+              "op": "performance_report",
+              "scope": "current"
+            }
+          }
+        ],
+        "tags": [
+          "system",
+          "control",
+          "grouped"
+        ],
+        "workflowHints": [
+          "Use pause/resume around invasive memory changes, and explain the impact of resets or power changes.",
+          "Combine background task operations with list_tasks to monitor long-running diagnostics."
+        ],
+        "platforms": [
+          "c64u",
+          "vice"
+        ],
+        "operationPlatforms": {
+          "pause": [
+            "c64u"
+          ],
+          "resume": [
+            "c64u"
+          ],
+          "menu": [
+            "c64u"
+          ]
+        }
+      }
+    },
+    {
+      "name": "c64_select_backend",
+      "title": "Changes the active backend without restarting the MCP server and reports resulting tool availability.",
+      "description": "Switch the active backend between C64U hardware and the VICE emulator at runtime.",
+      "inputSchema": {
+        "type": "object",
+        "description": "Runtime backend selection operations.",
+        "oneOf": [
+          {
+            "type": "object",
+            "description": "Switch the active runtime backend without restarting the MCP server.",
+            "properties": {
+              "op": {
+                "const": "select",
+                "description": "Selects the select operation."
+              },
+              "backend": {
+                "type": "string",
+                "enum": [
+                  "c64u",
+                  "vice"
+                ],
+                "description": "Backend to activate for subsequent tool calls."
+              }
+            },
+            "required": [
+              "op",
+              "backend"
+            ],
+            "additionalProperties": false
+          }
+        ],
+        "discriminator": {
+          "propertyName": "op"
+        }
+      },
+      "_meta": {
+        "domain": "platform",
+        "summary": "Changes the active backend without restarting the MCP server and reports resulting tool availability.",
+        "lifecycle": "request-response",
+        "resources": [
+          "c64://platform/status",
+          "c64://context/bootstrap"
+        ],
+        "prompts": [],
+        "examples": [
+          {
+            "name": "Switch to VICE",
+            "description": "Move subsequent tool calls to the emulator backend",
+            "arguments": {
+              "op": "select",
+              "backend": "vice"
+            }
+          }
+        ],
+        "tags": [
+          "platform",
+          "backend",
+          "grouped",
+          "switch"
+        ],
+        "workflowHints": [
+          "Switch backends before invoking backend-specific tools so platform gating stays accurate."
+        ],
+        "platforms": [
+          "c64u",
+          "vice"
+        ]
+      }
+    },
+    {
+      "name": "c64_graphics",
+      "title": "Captures frames, renders PETSCII text or art, previews sprites, and displays bitmap images from one tool.",
+      "description": "Grouped entry point for frame capture and graphics rendering workflows.",
+      "inputSchema": {
+        "type": "object",
+        "description": "Graphics operations available via the c64_graphics tool.",
+        "oneOf": [
+          {
+            "type": "object",
+            "description": "Capture one or more complete video frames from the active backend.",
+            "properties": {
+              "op": {
+                "const": "capture_frame"
+              },
+              "count": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Number of frames to capture.",
+                "minimum": 1,
+                "maximum": 32,
+                "default": 1
+              },
+              "includePixels": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Include pixel payload bytes in the response.",
+                "default": true
+              },
+              "encoding": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Encoding used for the pixel payload when included.",
+                "enum": [
+                  "base64",
+                  "hex"
+                ],
+                "default": "base64"
+              }
+            },
+            "required": [
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Create PETSCII art from prompts, text, or explicit bitmap data, and optionally display it on the C64.",
+            "properties": {
+              "prompt": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Natural language prompt describing the desired PETSCII art.",
+                "minLength": 1
+              },
+              "text": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Exact text to render in PETSCII (overrides prompt derivation).",
+                "minLength": 1
+              },
+              "maxWidth": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Maximum bitmap width in pixels (1-320).",
+                "minimum": 1,
+                "maximum": 320
+              },
+              "maxHeight": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Maximum bitmap height in pixels (1-200).",
+                "minimum": 1,
+                "maximum": 200
+              },
+              "borderColor": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Border colour index (0-15).",
+                "minimum": 0,
+                "maximum": 15
+              },
+              "backgroundColor": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Background colour index (0-15).",
+                "minimum": 0,
+                "maximum": 15
+              },
+              "foregroundColor": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Foreground colour index (0-15).",
+                "minimum": 0,
+                "maximum": 15
+              },
+              "dryRun": {
+                "type": "boolean",
+                "description": "When true, skip uploading the generated BASIC program to the C64.",
+                "default": false
+              },
+              "bitmap": {
+                "description": "Explicit bitmap definition for PETSCII rendering.",
+                "type": [
+                  "object",
+                  "null"
+                ],
+                "properties": {
+                  "width": {
+                    "type": "integer",
+                    "minimum": 1,
+                    "maximum": 320
+                  },
+                  "height": {
+                    "type": "integer",
+                    "minimum": 1,
+                    "maximum": 200
+                  },
+                  "pixels": {
+                    "type": "array",
+                    "items": {
+                      "type": "integer",
+                      "minimum": 0,
+                      "maximum": 1
+                    }
+                  }
+                },
+                "required": [
+                  "width",
+                  "height",
+                  "pixels"
+                ],
+                "additionalProperties": false
+              },
+              "op": {
+                "const": "render_petscii_art"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Display PETSCII text with optional border and background colours.",
+            "properties": {
+              "text": {
+                "type": "string",
+                "description": "The PETSCII text to print after clearing the screen.",
+                "minLength": 1
+              },
+              "borderColor": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Border colour index (0-15).",
+                "minimum": 0,
+                "maximum": 15
+              },
+              "backgroundColor": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Background colour index (0-15).",
+                "minimum": 0,
+                "maximum": 15
+              },
+              "op": {
+                "const": "render_petscii_text"
+              }
+            },
+            "required": [
+              "text",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Display supplied 63-byte sprite data at the requested position and colour by writing memory and patching VIC-II registers directly.",
+            "properties": {
+              "sprite": {
+                "description": "63-byte sprite definition provided as base64/hex string or array of bytes.",
+                "type": [
+                  "string",
+                  "array"
+                ],
+                "items": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "maximum": 255
+                },
+                "minItems": 63,
+                "maxItems": 63
+              },
+              "index": {
+                "type": "integer",
+                "description": "Sprite index (0-7) to configure in screen memory.",
+                "minimum": 0,
+                "maximum": 7,
+                "default": 0
+              },
+              "x": {
+                "type": "integer",
+                "description": "Sprite X position (0-511).",
+                "minimum": 0,
+                "maximum": 511,
+                "default": 100
+              },
+              "y": {
+                "type": "integer",
+                "description": "Sprite Y position (0-255).",
+                "minimum": 0,
+                "maximum": 255,
+                "default": 100
+              },
+              "color": {
+                "type": "integer",
+                "description": "Sprite colour index (0-15).",
+                "minimum": 0,
+                "maximum": 15,
+                "default": 1
+              },
+              "multicolour": {
+                "type": "boolean",
+                "description": "Enable multicolour mode for the sprite.",
+                "default": false
+              },
+              "op": {
+                "const": "render_sprite"
+              }
+            },
+            "required": [
+              "sprite",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Import an image file, convert it to VIC-II bitmap memory, write it into RAM, and display it.",
+            "properties": {
+              "imagePath": {
+                "type": "string",
+                "description": "Filesystem path of the source image (PNG, JPEG, BMP, GIF, TIFF, and other Jimp-supported formats).",
+                "minLength": 1
+              },
+              "format": {
+                "description": "Bitmap encoding mode to generate for the VIC-II display.",
+                "type": "string",
+                "enum": [
+                  "hires",
+                  "multicolor"
+                ]
+              },
+              "bitmapAddress": {
+                "description": "Absolute C64 memory address, provided as an integer or hex string such as $2000.",
+                "type": [
+                  "integer",
+                  "string",
+                  "null"
+                ],
+                "default": 8192
+              },
+              "screenAddress": {
+                "description": "Absolute C64 memory address, provided as an integer or hex string such as $2000.",
+                "type": [
+                  "integer",
+                  "string",
+                  "null"
+                ],
+                "default": 1024
+              },
+              "borderColor": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Border colour index (0-15).",
+                "minimum": 0,
+                "maximum": 15,
+                "default": 0
+              },
+              "backgroundColor": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Background colour index (0-15). Used for multicolor mode and aspect-ratio padding.",
+                "minimum": 0,
+                "maximum": 15,
+                "default": 0
+              },
+              "preserveAspect": {
+                "type": "boolean",
+                "description": "Preserve the source image aspect ratio and pad with the background colour.",
+                "default": true
+              },
+              "op": {
+                "const": "render_bitmap"
+              }
+            },
+            "required": [
+              "imagePath",
+              "format",
+              "op"
+            ],
+            "additionalProperties": false
+          }
+        ],
+        "discriminator": {
+          "propertyName": "op"
+        }
+      },
+      "_meta": {
+        "domain": "graphics",
+        "summary": "Captures frames, renders PETSCII text or art, previews sprites, and displays bitmap images from one tool.",
+        "lifecycle": "request-response",
+        "resources": [
+          "c64://specs/vic",
+          "c64://specs/basic",
+          "c64://specs/assembly"
+        ],
+        "prompts": [
+          "graphics-demo",
+          "basic-program",
+          "assembly-program"
+        ],
+        "examples": [
+          {
+            "name": "Capture one frame",
+            "description": "Grab the current framebuffer from the active backend",
+            "arguments": {
+              "op": "capture_frame"
+            }
+          },
+          {
+            "name": "Create PETSCII art (dry run)",
+            "description": "Synthesize art without uploading to the C64",
+            "arguments": {
+              "op": "render_petscii_art",
+              "prompt": "duck on a pond",
+              "dryRun": true
+            }
+          },
+          {
+            "name": "Render PETSCII text",
+            "description": "Print HELLO with blue border",
+            "arguments": {
+              "op": "render_petscii_text",
+              "text": "HELLO",
+              "borderColor": 6
+            }
+          },
+          {
+            "name": "Display sprite",
+            "description": "Show sprite data at coordinates",
+            "arguments": {
+              "op": "render_sprite",
+              "sprite": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+            }
+          },
+          {
+            "name": "Import bitmap image",
+            "description": "Convert a PNG into VIC bitmap memory and display it",
+            "arguments": {
+              "op": "render_bitmap",
+              "imagePath": "./artifacts/sample.png",
+              "format": "hires"
+            }
+          }
+        ],
+        "tags": [
+          "graphics",
+          "vic",
+          "grouped"
+        ],
+        "workflowHints": [
+          "Use render helpers for PETSCII text, PETSCII art, sprites, and bitmaps; clarify whether PETSCII art executed or stayed a dry run.",
+          "Mention sprite positions/colours so follow-up memory inspection stays grounded."
+        ],
+        "platforms": [
+          "c64u",
+          "vice"
+        ]
+      }
+    },
+    {
+      "name": "c64_rag",
+      "title": "Returns curated knowledge references for BASIC or 6502/6510 assembly queries.",
+      "description": "Grouped entry point for BASIC and assembly RAG lookups.",
+      "inputSchema": {
+        "type": "object",
+        "description": "RAG operations available via the c64_rag tool.",
+        "oneOf": [
+          {
+            "type": "object",
+            "description": "Retrieve BASIC references and snippets from the local knowledge base.",
+            "properties": {
+              "q": {
+                "type": "string",
+                "description": "Natural-language query describing the desired BASIC or assembly guidance.",
+                "minLength": 3
+              },
+              "k": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Maximum number of references to return (1-12).",
+                "minimum": 1,
+                "maximum": 12,
+                "default": 3
+              },
+              "op": {
+                "const": "basic"
+              }
+            },
+            "required": [
+              "q",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Retrieve 6502/6510 assembly references from the local knowledge base.",
+            "properties": {
+              "q": {
+                "type": "string",
+                "description": "Natural-language query describing the desired BASIC or assembly guidance.",
+                "minLength": 3
+              },
+              "k": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Maximum number of references to return (1-12).",
+                "minimum": 1,
+                "maximum": 12,
+                "default": 3
+              },
+              "op": {
+                "const": "asm"
+              }
+            },
+            "required": [
+              "q",
+              "op"
+            ],
+            "additionalProperties": false
+          }
+        ],
+        "discriminator": {
+          "propertyName": "op"
+        }
+      },
+      "_meta": {
+        "domain": "rag",
+        "summary": "Returns curated knowledge references for BASIC or 6502/6510 assembly queries.",
+        "lifecycle": "request-response",
+        "resources": [
+          "c64://specs/basic",
+          "c64://specs/assembly",
+          "c64://context/bootstrap"
+        ],
+        "prompts": [
+          "basic-program",
+          "assembly-program"
+        ],
+        "examples": [
+          {
+            "name": "Retrieve BASIC snippet",
+            "description": "Search for device 4 printing guidance",
+            "arguments": {
+              "op": "basic",
+              "q": "basic print device 4"
+            }
+          },
+          {
+            "name": "Retrieve assembly snippet",
+            "description": "Search for raster IRQ examples",
+            "arguments": {
+              "op": "asm",
+              "q": "stable raster irq"
+            }
+          }
+        ],
+        "tags": [
+          "rag",
+          "search",
+          "reference",
+          "grouped"
+        ],
+        "workflowHints": [
+          "Use BASIC retrieval before synthesising new BASIC code and mention primary resources in responses.",
+          "For assembly, note registers or addresses surfaced so the user can inspect them further."
+        ],
+        "platforms": [
+          "c64u",
+          "vice"
+        ]
+      }
+    },
+    {
+      "name": "c64_disk",
+      "title": "Mount or unmount images, create new disks, list drives, and find programs from one tool.",
+      "description": "Grouped entry point for disk mounts, listings, image creation, and program discovery.",
+      "inputSchema": {
+        "type": "object",
+        "description": "Disk operations available via the c64_disk tool.",
+        "oneOf": [
+          {
+            "type": "object",
+            "description": "List Ultimate drive slots and their mounted images.",
+            "properties": {
+              "op": {
+                "const": "list_drives"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Mount a disk image with optional verification and retries.",
+            "properties": {
+              "drive": {
+                "type": "string",
+                "description": "Drive identifier (for example drive8).",
+                "minLength": 1
+              },
+              "image": {
+                "type": "string",
+                "description": "Absolute or Ultimate filesystem path to the disk image.",
+                "minLength": 1
+              },
+              "type": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Override detected image type when firmware guesses incorrectly.",
+                "enum": [
+                  "d64",
+                  "g64",
+                  "d71",
+                  "g71",
+                  "d81"
+                ]
+              },
+              "attachmentMode": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Attachment mode controlling how the firmware treats the mounted image.",
+                "enum": [
+                  "readwrite",
+                  "readonly",
+                  "unlinked"
+                ]
+              },
+              "driveMode": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Drive emulation mode to switch to during verification.",
+                "enum": [
+                  "1541",
+                  "1571",
+                  "1581"
+                ]
+              },
+              "verify": {
+                "type": "boolean",
+                "description": "When true, power on/reset/verify using the reliability workflow.",
+                "default": false
+              },
+              "powerOnIfNeeded": {
+                "type": "boolean",
+                "description": "Power on the drive automatically before mounting when verify=true.",
+                "default": true
+              },
+              "resetAfterMount": {
+                "type": "boolean",
+                "description": "Issue a drive reset after mounting when verify=true.",
+                "default": true
+              },
+              "maxRetries": {
+                "type": "integer",
+                "description": "Maximum number of mount retries when verify=true.",
+                "minimum": 0,
+                "maximum": 5,
+                "default": 2
+              },
+              "retryDelayMs": {
+                "type": "integer",
+                "description": "Delay between mount retry attempts when verify=true.",
+                "minimum": 0,
+                "maximum": 5000,
+                "default": 500
+              },
+              "op": {
+                "const": "mount"
+              }
+            },
+            "required": [
+              "drive",
+              "image",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Remove the mounted image from an Ultimate drive slot.",
+            "properties": {
+              "drive": {
+                "type": "string",
+                "description": "Drive identifier such as drive8, drive9, or unit name defined in the Ultimate UI.",
+                "minLength": 1
+              },
+              "op": {
+                "const": "unmount"
+              }
+            },
+            "required": [
+              "drive",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Inspect metadata for a file on the Ultimate filesystem.",
+            "properties": {
+              "path": {
+                "type": "string",
+                "description": "Absolute or Ultimate filesystem path to the disk image to mount or manage.",
+                "minLength": 1
+              },
+              "op": {
+                "const": "file_info"
+              }
+            },
+            "required": [
+              "path",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Create a blank disk image of the specified format.",
+            "properties": {
+              "format": {
+                "type": "string",
+                "description": "Disk image format to create.",
+                "enum": [
+                  "d64",
+                  "d71",
+                  "d81",
+                  "dnp"
+                ]
+              },
+              "path": {
+                "type": "string",
+                "description": "Destination path on the Ultimate filesystem.",
+                "minLength": 1
+              },
+              "diskname": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Optional disk label (1-16 characters, converted to PETSCII).",
+                "minLength": 1,
+                "maxLength": 16
+              },
+              "tracks": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Track count (D64 supports 35 or 40; DNP requires explicit tracks).",
+                "minimum": 1,
+                "maximum": 255
+              },
+              "op": {
+                "const": "create_image"
+              }
+            },
+            "required": [
+              "format",
+              "path",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Search for a PRG/CRT by name substring and run the first match.",
+            "properties": {
+              "root": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Root path to search",
+                "minLength": 1,
+                "default": "/"
+              },
+              "nameContains": {
+                "type": "string",
+                "description": "Substring to match",
+                "minLength": 1
+              },
+              "extensions": {
+                "type": [
+                  "array",
+                  "null"
+                ],
+                "items": {
+                  "type": "string",
+                  "description": "File extensions to include (without dot)",
+                  "minLength": 1
+                }
+              },
+              "caseInsensitive": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Case-insensitive name match",
+                "default": true
+              },
+              "sort": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Sort order for matches",
+                "enum": [
+                  "discovered",
+                  "alphabetical"
+                ],
+                "default": "discovered"
+              },
+              "waitMs": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Delay after firmware run before returning",
+                "minimum": 0,
+                "default": 0
+              },
+              "captureCandidates": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Include up to this many candidates in result",
+                "minimum": 1,
+                "maximum": 100,
+                "default": 10
+              },
+              "op": {
+                "const": "find_and_run"
+              }
+            },
+            "required": [
+              "nameContains",
+              "op"
+            ],
+            "additionalProperties": false
+          }
+        ],
+        "discriminator": {
+          "propertyName": "op"
+        }
+      },
+      "_meta": {
+        "domain": "storage",
+        "summary": "Mount or unmount images, create new disks, list drives, and find programs from one tool.",
+        "lifecycle": "request-response",
+        "resources": [
+          "c64://context/bootstrap"
+        ],
+        "prompts": [
+          "drive-management"
+        ],
+        "examples": [
+          {
+            "name": "Mount image with verification",
+            "description": "Power on drive8, mount image, and verify",
+            "arguments": {
+              "op": "mount",
+              "drive": "drive8",
+              "image": "/tmp/demo.d64",
+              "verify": true
+            }
+          },
+          {
+            "name": "Create D81",
+            "description": "Create blank D81 image",
+            "arguments": {
+              "op": "create_image",
+              "format": "d81",
+              "path": "/tmp/new.d81"
+            }
+          },
+          {
+            "name": "List drives",
+            "description": "Fetch drive status",
+            "arguments": {
+              "op": "list_drives"
+            }
+          }
+        ],
+        "tags": [
+          "storage",
+          "drive",
+          "grouped"
+        ],
+        "workflowHints": [
+          "Summarise drive state before and after mounts so the user can confirm hardware changes.",
+          "Call out when verification retries succeed or fail so follow-up actions are clear."
+        ],
+        "platforms": [
+          "c64u",
+          "vice"
+        ],
+        "operationPlatforms": {
+          "file_info": [
+            "c64u"
+          ],
+          "create_image": [
+            "c64u"
+          ],
+          "find_and_run": [
+            "c64u"
+          ]
+        }
+      }
+    },
+    {
+      "name": "c64_drive",
+      "title": "Power cycle drive slots, reset IEC state, switch emulation modes, or load custom ROMs.",
+      "description": "Grouped entry point for drive power, mode, reset, and ROM operations.",
+      "inputSchema": {
+        "type": "object",
+        "description": "Drive operations available via the c64_drive tool.",
+        "oneOf": [
+          {
+            "type": "object",
+            "description": "Issue an IEC reset for the selected drive slot.",
+            "properties": {
+              "drive": {
+                "type": "string",
+                "description": "Drive identifier such as drive8, drive9, or unit name defined in the Ultimate UI.",
+                "minLength": 1
+              },
+              "op": {
+                "const": "reset"
+              }
+            },
+            "required": [
+              "drive",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Power on a specific Ultimate drive slot.",
+            "properties": {
+              "drive": {
+                "type": "string",
+                "description": "Drive identifier such as drive8, drive9, or unit name defined in the Ultimate UI.",
+                "minLength": 1
+              },
+              "op": {
+                "const": "power_on"
+              }
+            },
+            "required": [
+              "drive",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Power off a specific Ultimate drive slot.",
+            "properties": {
+              "drive": {
+                "type": "string",
+                "description": "Drive identifier such as drive8, drive9, or unit name defined in the Ultimate UI.",
+                "minLength": 1
+              },
+              "op": {
+                "const": "power_off"
+              }
+            },
+            "required": [
+              "drive",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Temporarily load a custom ROM into an Ultimate drive slot.",
+            "properties": {
+              "drive": {
+                "type": "string",
+                "description": "Drive identifier such as drive8, drive9, or unit name defined in the Ultimate UI.",
+                "minLength": 1
+              },
+              "path": {
+                "type": "string",
+                "description": "Absolute or Ultimate filesystem path to the disk image to mount or manage.",
+                "minLength": 1
+              },
+              "op": {
+                "const": "load_rom"
+              }
+            },
+            "required": [
+              "drive",
+              "path",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Set the emulation mode for a drive slot (1541/1571/1581).",
+            "properties": {
+              "drive": {
+                "type": "string",
+                "description": "Drive identifier such as drive8, drive9, or unit name defined in the Ultimate UI.",
+                "minLength": 1
+              },
+              "mode": {
+                "type": "string",
+                "description": "Drive hardware profile to emulate.",
+                "enum": [
+                  "1541",
+                  "1571",
+                  "1581"
+                ]
+              },
+              "op": {
+                "const": "set_mode"
+              }
+            },
+            "required": [
+              "drive",
+              "mode",
+              "op"
+            ],
+            "additionalProperties": false
+          }
+        ],
+        "discriminator": {
+          "propertyName": "op"
+        }
+      },
+      "_meta": {
+        "domain": "drive",
+        "summary": "Power cycle drive slots, reset IEC state, switch emulation modes, or load custom ROMs.",
+        "lifecycle": "request-response",
+        "resources": [
+          "c64://context/bootstrap"
+        ],
+        "prompts": [],
+        "examples": [
+          {
+            "name": "Power on drive",
+            "description": "Enable drive8",
+            "arguments": {
+              "op": "power_on",
+              "drive": "drive8"
+            }
+          },
+          {
+            "name": "Set 1581 mode",
+            "description": "Switch emulation mode",
+            "arguments": {
+              "op": "set_mode",
+              "drive": "drive8",
+              "mode": "1581"
+            }
+          }
+        ],
+        "tags": [
+          "drive",
+          "hardware",
+          "grouped"
+        ],
+        "workflowHints": [
+          "State the resulting power/mode/ROM so the user can reconcile IEC behaviour.",
+          "Suggest running c64_disk (op list_drives) to confirm status when appropriate."
+        ],
+        "platforms": [
+          "c64u",
+          "vice"
+        ],
+        "operationPlatforms": {
+          "load_rom": [
+            "c64u"
+          ]
+        }
+      }
+    },
+    {
+      "name": "c64_printer",
+      "title": "Print text or bitmaps and define custom characters for Commodore or Epson printers.",
+      "description": "Grouped entry point for Commodore and Epson printing helpers.",
+      "inputSchema": {
+        "type": "object",
+        "description": "Printer operations available via the c64_printer tool.",
+        "oneOf": [
+          {
+            "type": "object",
+            "description": "Generate BASIC that prints text to device 4.",
+            "properties": {
+              "text": {
+                "type": "string",
+                "description": "Text to print on the connected printer.",
+                "minLength": 1
+              },
+              "target": {
+                "description": "Printer target: Commodore MPS (PETSCII) or Epson FX (ESC/P).",
+                "type": "string",
+                "enum": [
+                  "commodore",
+                  "epson"
+                ],
+                "default": "commodore"
+              },
+              "secondaryAddress": {
+                "description": "Secondary address for device 4 (0 = upper/graphics, 7 = lowercase).",
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "enum": [
+                  0,
+                  7
+                ]
+              },
+              "formFeed": {
+                "type": "boolean",
+                "description": "Emit a form-feed (CHR$(12)) at the end of the job.",
+                "default": false
+              },
+              "op": {
+                "const": "print_text"
+              }
+            },
+            "required": [
+              "text",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Print a bitmap row via Commodore (BIM) or Epson ESC/P workflows.",
+            "properties": {
+              "printer": {
+                "type": "string",
+                "description": "Target printer family.",
+                "enum": [
+                  "commodore",
+                  "epson"
+                ],
+                "default": "commodore"
+              },
+              "columns": {
+                "type": "array",
+                "description": "Sequence of bitmap columns.",
+                "items": {
+                  "type": "integer",
+                  "description": "Bitmap column byte (0-255).",
+                  "minimum": 0,
+                  "maximum": 255
+                },
+                "minItems": 1
+              },
+              "repeats": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Number of times to repeat the row (1-255).",
+                "minimum": 1,
+                "maximum": 255
+              },
+              "useSubRepeat": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Repeat the next byte this many times (Commodore BIM SUB).",
+                "minimum": 1,
+                "maximum": 255
+              },
+              "secondaryAddress": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Secondary address for device 4 (0 or 7).",
+                "minimum": 0,
+                "maximum": 7
+              },
+              "ensureMsb": {
+                "type": "boolean",
+                "description": "Ensure MSB set for Commodore printers.",
+                "default": true
+              },
+              "mode": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Epson ESC/P graphics mode (K/L/Y/Z/*).",
+                "minLength": 1,
+                "maxLength": 1
+              },
+              "density": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Density parameter when using Epson mode '*'.",
+                "minimum": 0,
+                "maximum": 3
+              },
+              "timesPerLine": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Number of times to print the row per line (1-10).",
+                "minimum": 1,
+                "maximum": 10
+              },
+              "op": {
+                "const": "print_bitmap"
+              }
+            },
+            "required": [
+              "printer",
+              "columns",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Define custom printer characters (Commodore DLL mode).",
+            "properties": {
+              "firstChar": {
+                "type": "integer",
+                "description": "PETSCII code of first character to redefine (33-126).",
+                "minimum": 33,
+                "maximum": 126
+              },
+              "chars": {
+                "type": "array",
+                "description": "Character definitions to upload (1-32).",
+                "items": {
+                  "type": "object",
+                  "description": "Commodore MPS DLL character definition (11 columns).",
+                  "properties": {
+                    "a": {
+                      "description": "Attribute flag (0=normal, 1=graphics).",
+                      "type": [
+                        "integer",
+                        "null"
+                      ],
+                      "enum": [
+                        0,
+                        1
+                      ]
+                    },
+                    "columns": {
+                      "type": "array",
+                      "description": "11 column bytes describing the character.",
+                      "items": {
+                        "type": "integer",
+                        "description": "Column byte (0-255).",
+                        "minimum": 0,
+                        "maximum": 255
+                      },
+                      "minItems": 11,
+                      "maxItems": 11
+                    }
+                  },
+                  "required": [
+                    "columns"
+                  ],
+                  "additionalProperties": false
+                },
+                "minItems": 1,
+                "maxItems": 32
+              },
+              "secondaryAddress": {
+                "description": "Secondary address for device 4 (0 = upper/graphics, 7 = lowercase).",
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "enum": [
+                  0,
+                  7
+                ]
+              },
+              "op": {
+                "const": "define_chars"
+              }
+            },
+            "required": [
+              "firstChar",
+              "chars",
+              "op"
+            ],
+            "additionalProperties": false
+          }
+        ],
+        "discriminator": {
+          "propertyName": "op"
+        }
+      },
+      "_meta": {
+        "domain": "printer",
+        "summary": "Print text or bitmaps and define custom characters for Commodore or Epson printers.",
+        "lifecycle": "request-response",
+        "resources": [
+          "c64://context/bootstrap"
+        ],
+        "prompts": [],
+        "examples": [
+          {
+            "name": "Print text",
+            "description": "Generate BASIC for device 4",
+            "arguments": {
+              "op": "print_text",
+              "text": "HELLO",
+              "ensureReturn": true
+            }
+          },
+          {
+            "name": "Print bitmap",
+            "description": "Send Epson graphics row",
+            "arguments": {
+              "op": "print_bitmap",
+              "printer": "epson",
+              "columns": [
+                0,
+                255,
+                0
+              ],
+              "mode": "*",
+              "density": 3
+            }
+          }
+        ],
+        "tags": [
+          "printer",
+          "device",
+          "grouped"
+        ],
+        "workflowHints": [
+          "Mention device/secondary addresses so the user knows which printer workflow ran.",
+          "When defining characters, remind the user to send the BASIC program returned in the payload."
+        ],
+        "platforms": [
+          "c64u"
+        ]
+      }
+    },
+    {
+      "name": "c64_config",
+      "title": "List or update settings, access firmware info, take snapshots, and run program shuffle workflows.",
+      "description": "Grouped entry point for configuration reads/writes, diagnostics, and snapshots.",
+      "inputSchema": {
+        "type": "object",
+        "description": "Configuration operations available via the c64_config tool.",
+        "oneOf": [
+          {
+            "type": "object",
+            "description": "List configuration categories reported by the firmware.",
+            "properties": {
+              "op": {
+                "const": "list"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Read a configuration category or specific item.",
+            "properties": {
+              "category": {
+                "type": "string",
+                "description": "Configuration category reported by the Ultimate firmware (e.g. 'Audio').",
+                "minLength": 1
+              },
+              "item": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Specific configuration item inside the selected category (e.g. 'Volume').",
+                "minLength": 1
+              },
+              "op": {
+                "const": "get"
+              }
+            },
+            "required": [
+              "category",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Write a configuration value in the selected category.",
+            "properties": {
+              "category": {
+                "type": "string",
+                "description": "Configuration category reported by the Ultimate firmware (e.g. 'Audio').",
+                "minLength": 1
+              },
+              "item": {
+                "type": "string",
+                "description": "Configuration item name inside the category.",
+                "minLength": 1
+              },
+              "value": {
+                "description": "Primitive configuration value (string, number, or boolean).",
+                "type": [
+                  "string",
+                  "number",
+                  "boolean"
+                ]
+              },
+              "op": {
+                "const": "set"
+              }
+            },
+            "required": [
+              "category",
+              "item",
+              "value",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "description": "Apply multiple configuration updates in a single request.",
+            "type": "object",
+            "additionalProperties": {
+              "type": "object",
+              "additionalProperties": {
+                "type": [
+                  "string",
+                  "number",
+                  "boolean"
+                ]
+              }
+            },
+            "properties": {
+              "op": {
+                "const": "batch_update"
+              }
+            },
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Load configuration from flash storage.",
+            "properties": {
+              "op": {
+                "const": "load_flash"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Persist the current configuration to flash storage.",
+            "properties": {
+              "op": {
+                "const": "save_flash"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Reset firmware configuration to factory defaults.",
+            "properties": {
+              "op": {
+                "const": "reset_defaults"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Read the Ultimate debug register ($D7FF).",
+            "properties": {
+              "op": {
+                "const": "read_debugreg"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Write a hex value to the Ultimate debug register ($D7FF).",
+            "properties": {
+              "value": {
+                "type": "string",
+                "description": "Hex value (00-FF) to write to the debug register.",
+                "minLength": 1,
+                "maxLength": 2,
+                "pattern": "^[0-9A-Fa-f]{1,2}$"
+              },
+              "op": {
+                "const": "write_debugreg"
+              }
+            },
+            "required": [
+              "value",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Retrieve Ultimate hardware information and status.",
+            "properties": {
+              "op": {
+                "const": "info"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Fetch firmware version details.",
+            "properties": {
+              "op": {
+                "const": "version"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Snapshot configuration to disk for later restore or diff.",
+            "properties": {
+              "path": {
+                "type": "string",
+                "description": "Absolute or workspace-relative path where the snapshot file will be written.",
+                "minLength": 1
+              },
+              "op": {
+                "const": "snapshot"
+              }
+            },
+            "required": [
+              "path",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Restore configuration from a snapshot file.",
+            "properties": {
+              "path": {
+                "type": "string",
+                "description": "Snapshot file to read (must contain categories payload).",
+                "minLength": 1
+              },
+              "applyToFlash": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "When true, save the restored configuration to flash immediately.",
+                "default": false
+              },
+              "op": {
+                "const": "restore"
+              }
+            },
+            "required": [
+              "path",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Compare the current configuration with a snapshot.",
+            "properties": {
+              "path": {
+                "type": "string",
+                "description": "Snapshot file to compare with.",
+                "minLength": 1
+              },
+              "op": {
+                "const": "diff"
+              }
+            },
+            "required": [
+              "path",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Discover PRG/CRT files and run each with optional screen capture.",
+            "properties": {
+              "root": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Root path to search for programs",
+                "minLength": 1,
+                "default": "/"
+              },
+              "extensions": {
+                "type": [
+                  "array",
+                  "null"
+                ],
+                "items": {
+                  "type": "string",
+                  "description": "File extensions to include (without dot)",
+                  "minLength": 1
+                },
+                "default": [
+                  "prg",
+                  "crt"
+                ]
+              },
+              "durationMs": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Duration to run each program in milliseconds",
+                "minimum": 1,
+                "default": 5000
+              },
+              "captureScreen": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Capture screen after each run",
+                "default": true
+              },
+              "maxPrograms": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Maximum number of programs to run",
+                "minimum": 1,
+                "default": 10
+              },
+              "outputPath": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Output directory for run logs and captures",
+                "minLength": 1
+              },
+              "resetDelayMs": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Delay after reset operations to allow the platform to settle.",
+                "minimum": 0,
+                "maximum": 1000,
+                "default": 100
+              },
+              "op": {
+                "const": "shuffle"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          }
+        ],
+        "discriminator": {
+          "propertyName": "op"
+        }
+      },
+      "_meta": {
+        "domain": "config",
+        "summary": "List or update settings, access firmware info, take snapshots, and run program shuffle workflows.",
+        "lifecycle": "request-response",
+        "resources": [
+          "c64://context/bootstrap",
+          "c64://docs/index"
+        ],
+        "prompts": [
+          "memory-debug"
+        ],
+        "examples": [
+          {
+            "name": "List categories",
+            "description": "Enumerate configuration categories",
+            "arguments": {
+              "op": "list"
+            }
+          },
+          {
+            "name": "Set volume",
+            "description": "Adjust audio volume to 70",
+            "arguments": {
+              "op": "set",
+              "category": "Audio",
+              "item": "Volume",
+              "value": 70
+            }
+          },
+          {
+            "name": "Snapshot config",
+            "description": "Write configuration snapshot to disk",
+            "arguments": {
+              "op": "snapshot",
+              "path": "./snapshots/c64_json"
+            }
+          }
+        ],
+        "tags": [
+          "config",
+          "diagnostics",
+          "grouped"
+        ],
+        "workflowHints": [
+          "List categories before changing values so users can confirm firmware-provided names.",
+          "Mention when operations persist to flash or modify debug registers to highlight impacts.",
+          "Call out snapshot file paths so users can version-control or reuse them later."
+        ],
+        "platforms": [
+          "c64u",
+          "vice"
+        ],
+        "operationPlatforms": {
+          "load_flash": [
+            "c64u"
+          ],
+          "save_flash": [
+            "c64u"
+          ],
+          "reset_defaults": [
+            "c64u"
+          ],
+          "read_debugreg": [
+            "c64u"
+          ],
+          "write_debugreg": [
+            "c64u"
+          ],
+          "shuffle": [
+            "c64u"
+          ]
+        }
+      }
+    },
+    {
+      "name": "c64_extract",
+      "title": "Export sprites or charsets, dump RAM, compute filesystem stats, or run firmware health checks.",
+      "description": "Grouped entry point for sprite/charset extraction, memory dumps, filesystem stats, and firmware health checks.",
+      "inputSchema": {
+        "type": "object",
+        "description": "Extraction operations available via the c64_extract tool.",
+        "oneOf": [
+          {
+            "type": "object",
+            "description": "Scan RAM for sprites and optionally export .spr files.",
+            "properties": {
+              "address": {
+                "type": "string",
+                "description": "Start address ($HHHH or decimal)",
+                "minLength": 1
+              },
+              "length": {
+                "type": "integer",
+                "description": "Number of bytes to scan",
+                "minimum": 63,
+                "maximum": 65536
+              },
+              "stride": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Stride between sprite candidates in bytes",
+                "minimum": 1,
+                "default": 64
+              },
+              "maxSprites": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Maximum sprites to return",
+                "minimum": 1,
+                "maximum": 256,
+                "default": 16
+              },
+              "minNonZeroRows": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Minimum non-empty rows required",
+                "minimum": 1,
+                "maximum": 21,
+                "default": 4
+              },
+              "minSetBits": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Minimum number of set bits required",
+                "minimum": 1,
+                "maximum": 504,
+                "default": 12
+              },
+              "includeBase64": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Include base64 data in response",
+                "default": true
+              },
+              "outputDir": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Directory to write .spr files",
+                "minLength": 1
+              },
+              "pauseDuringRead": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Pause the machine during memory read",
+                "default": true
+              },
+              "op": {
+                "const": "sprites"
+              }
+            },
+            "required": [
+              "address",
+              "length",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Locate and extract 2KB character sets from RAM.",
+            "properties": {
+              "address": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Start address to scan ($HHHH or decimal). If not provided, scans common locations.",
+                "minLength": 1
+              },
+              "scanRange": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Range to scan if address not provided: 'common' or 'full'",
+                "enum": [
+                  "common",
+                  "full"
+                ],
+                "default": "common"
+              },
+              "outputPath": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "File path to write charset binary",
+                "minLength": 1
+              },
+              "pauseDuringRead": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Pause the machine during memory read",
+                "default": true
+              },
+              "minNonEmptyChars": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Minimum non-empty characters required",
+                "minimum": 1,
+                "maximum": 256,
+                "default": 32
+              },
+              "minEntropy": {
+                "type": [
+                  "number",
+                  "null"
+                ],
+                "description": "Minimum average entropy threshold",
+                "minimum": 0,
+                "maximum": 1,
+                "default": 0.3
+              },
+              "op": {
+                "const": "charset"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Dump a RAM range to hex or binary files with manifest metadata.",
+            "properties": {
+              "address": {
+                "type": "string",
+                "description": "Start address ($HHHH or decimal)",
+                "minLength": 1
+              },
+              "length": {
+                "type": "integer",
+                "description": "Number of bytes to dump",
+                "minimum": 1,
+                "maximum": 65536
+              },
+              "outputPath": {
+                "type": "string",
+                "description": "Destination file path",
+                "minLength": 1
+              },
+              "format": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Output format: hex|binary",
+                "enum": [
+                  "hex",
+                  "binary"
+                ],
+                "default": "hex"
+              },
+              "chunkSize": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Chunk size for reads",
+                "minimum": 1,
+                "maximum": 4096,
+                "default": 512
+              },
+              "pauseDuringRead": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Pause/resume around dump",
+                "default": true
+              },
+              "retries": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Retries per chunk on failure",
+                "minimum": 0,
+                "default": 1
+              },
+              "op": {
+                "const": "memory_dump"
+              }
+            },
+            "required": [
+              "address",
+              "length",
+              "outputPath",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Walk the filesystem and aggregate counts/bytes by extension.",
+            "properties": {
+              "root": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Root path to scan",
+                "minLength": 1,
+                "default": "/"
+              },
+              "extensions": {
+                "type": [
+                  "array",
+                  "null"
+                ],
+                "items": {
+                  "type": "string",
+                  "description": "Limit to these extensions (without dot)",
+                  "minLength": 1
+                }
+              },
+              "includeContainers": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Include container images (d64/d81/etc.) in extension stats",
+                "default": true
+              },
+              "maxSamplesPerExtension": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Number of sample paths to keep per extension",
+                "minimum": 1,
+                "maximum": 10,
+                "default": 3
+              },
+              "op": {
+                "const": "fs_stats"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          },
+          {
+            "type": "object",
+            "description": "Run firmware readiness checks and report status metrics.",
+            "properties": {
+              "op": {
+                "const": "firmware_health"
+              }
+            },
+            "additionalProperties": false,
+            "required": [
+              "op"
+            ]
+          }
+        ],
+        "discriminator": {
+          "propertyName": "op"
+        }
+      },
+      "_meta": {
+        "domain": "extract",
+        "summary": "Export sprites or charsets, dump RAM, compute filesystem stats, or run firmware health checks.",
+        "lifecycle": "request-response",
+        "resources": [
+          "c64://context/bootstrap",
+          "c64://specs/basic",
+          "c64://specs/assembly"
+        ],
+        "prompts": [],
+        "examples": [
+          {
+            "name": "Dump RAM to file",
+            "description": "Write $0400-$07FF to hex file",
+            "arguments": {
+              "op": "memory_dump",
+              "address": "$0400",
+              "length": 1024,
+              "outputPath": "./dumps/screen.hex"
+            }
+          },
+          {
+            "name": "Scan sprites",
+            "description": "Scan $2000 for sprites",
+            "arguments": {
+              "op": "sprites",
+              "address": "$2000",
+              "length": 2048
+            }
+          }
+        ],
+        "tags": [
+          "extract",
+          "diagnostics",
+          "grouped"
+        ],
+        "workflowHints": [
+          "Pause the machine when advised so dumps and sprite scans remain stable.",
+          "Summarise output file paths or sample counts so users can inspect artifacts quickly."
+        ],
+        "platforms": [
+          "c64u"
+        ]
+      }
+    },
+    {
+      "name": "c64_stream",
+      "title": "Start or stop audio/video/debug streaming in a single tool.",
+      "description": "Grouped entry point for starting and stopping Ultimate streaming sessions.",
+      "inputSchema": {
+        "type": "object",
+        "description": "Streaming operations available via the c64_stream tool.",
+        "oneOf": [
+          {
+            "type": "object",
+            "description": "Start an Ultimate streaming session toward a host:port target.",
+            "properties": {
+              "stream": {
+                "type": "string",
+                "description": "Stream type to control (video/audio/debug).",
+                "enum": [
+                  "video",
+                  "audio",
+                  "debug"
+                ]
+              },
+              "target": {
+                "type": "string",
+                "description": "Destination host:port or UDP target understood by the firmware.",
+                "minLength": 3
+              },
+              "op": {
+                "const": "start"
+              }
+            },
+            "required": [
+              "stream",
+              "target",
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Stop an active Ultimate streaming session.",
+            "properties": {
+              "stream": {
+                "type": "string",
+                "description": "Stream type to control (video/audio/debug).",
+                "enum": [
+                  "video",
+                  "audio",
+                  "debug"
+                ]
+              },
+              "op": {
+                "const": "stop"
+              }
+            },
+            "required": [
+              "stream",
+              "op"
+            ],
+            "additionalProperties": false
+          }
+        ],
+        "discriminator": {
+          "propertyName": "op"
+        }
+      },
+      "_meta": {
+        "domain": "stream",
+        "summary": "Start or stop audio/video/debug streaming in a single tool.",
+        "lifecycle": "request-response",
+        "resources": [
+          "c64://docs/index",
+          "c64://specs/sid"
+        ],
+        "prompts": [
+          "sid-music"
+        ],
+        "examples": [
+          {
+            "name": "Start audio stream",
+            "description": "Send audio to localhost",
+            "arguments": {
+              "op": "start",
+              "stream": "audio",
+              "target": "127.0.0.1:9000"
+            }
+          },
+          {
+            "name": "Stop audio stream",
+            "description": "Stop streaming",
+            "arguments": {
+              "op": "stop",
+              "stream": "audio"
+            }
+          }
+        ],
+        "tags": [
+          "stream",
+          "monitor",
+          "grouped"
+        ],
+        "workflowHints": [
+          "Confirm stream targets for the user so they can connect their tooling.",
+          "Remind users to stop streams when capture completes to free resources."
+        ],
+        "platforms": [
+          "c64u"
+        ]
+      }
+    },
+    {
+      "name": "c64_debug",
+      "title": "Manage breakpoints, inspect registers, and step through code on the VICE backend.",
+      "description": "Grouped entry point for VICE debugger operations (breakpoints, registers, stepping).",
+      "inputSchema": {
+        "type": "object",
+        "description": "Available debugger operations.",
+        "oneOf": [
+          {
+            "type": "object",
+            "description": "List all active VICE checkpoints (breakpoints).",
+            "properties": {
+              "op": {
+                "const": "list_checkpoints"
+              }
+            },
+            "required": [
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Fetch a single checkpoint by id.",
+            "properties": {
+              "op": {
+                "const": "get_checkpoint"
+              },
+              "id": {
+                "type": "integer",
+                "description": "Debugger checkpoint identifier.",
+                "minimum": 1
+              }
+            },
+            "required": [
+              "op",
+              "id"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Create a new checkpoint (breakpoint) in VICE.",
+            "properties": {
+              "op": {
+                "const": "create_checkpoint"
+              },
+              "address": {
+                "type": "string",
+                "description": "Start address (e.g. $0801).",
+                "minLength": 1
+              },
+              "endAddress": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Optional end address for range.",
+                "minLength": 1
+              },
+              "stopOnHit": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Pause execution when hit (default true).",
+                "default": true
+              },
+              "enabled": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Whether the checkpoint is enabled (default true).",
+                "default": true
+              },
+              "temporary": {
+                "type": [
+                  "boolean",
+                  "null"
+                ],
+                "description": "Automatically remove after first hit.",
+                "default": false
+              },
+              "operations": {
+                "type": [
+                  "object",
+                  "null"
+                ],
+                "description": "Checkpoint operation filters.",
+                "properties": {
+                  "execute": {
+                    "type": [
+                      "boolean",
+                      "null"
+                    ],
+                    "description": "Trigger on execute (default true).",
+                    "default": true
+                  },
+                  "load": {
+                    "type": [
+                      "boolean",
+                      "null"
+                    ],
+                    "description": "Trigger on memory load.",
+                    "default": false
+                  },
+                  "store": {
+                    "type": [
+                      "boolean",
+                      "null"
+                    ],
+                    "description": "Trigger on memory store.",
+                    "default": false
+                  }
+                },
+                "additionalProperties": false
+              },
+              "memspace": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "VICE memory space (0=CPU, 1=Drive8, etc.).",
+                "minimum": 0,
+                "maximum": 4
+              }
+            },
+            "required": [
+              "op",
+              "address"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Remove a checkpoint by id.",
+            "properties": {
+              "op": {
+                "const": "delete_checkpoint"
+              },
+              "id": {
+                "type": "integer",
+                "description": "Debugger checkpoint identifier.",
+                "minimum": 1
+              }
+            },
+            "required": [
+              "op",
+              "id"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Enable or disable a checkpoint by id.",
+            "properties": {
+              "op": {
+                "const": "toggle_checkpoint"
+              },
+              "id": {
+                "type": "integer",
+                "description": "Debugger checkpoint identifier.",
+                "minimum": 1
+              },
+              "enabled": {
+                "type": "boolean",
+                "description": "Set to true to enable, false to disable."
+              }
+            },
+            "required": [
+              "op",
+              "id",
+              "enabled"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Attach a conditional expression to a checkpoint.",
+            "properties": {
+              "op": {
+                "const": "set_condition"
+              },
+              "id": {
+                "type": "integer",
+                "description": "Debugger checkpoint identifier.",
+                "minimum": 1
+              },
+              "expression": {
+                "type": "string",
+                "description": "VICE monitor conditional expression.",
+                "minLength": 1
+              }
+            },
+            "required": [
+              "op",
+              "id",
+              "expression"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "List available registers (metadata).",
+            "properties": {
+              "op": {
+                "const": "list_registers"
+              },
+              "memspace": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "VICE memory space (0=CPU, 1=Drive8, etc.).",
+                "minimum": 0,
+                "maximum": 4
+              }
+            },
+            "required": [
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Read register values, optionally filtered by name or id.",
+            "properties": {
+              "op": {
+                "const": "get_registers"
+              },
+              "memspace": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "VICE memory space (0=CPU, 1=Drive8, etc.).",
+                "minimum": 0,
+                "maximum": 4
+              },
+              "registers": {
+                "type": [
+                  "array",
+                  "null"
+                ],
+                "description": "Registers to include.",
+                "items": {
+                  "type": "object",
+                  "description": "Selects a register by id or name.",
+                  "properties": {
+                    "name": {
+                      "type": [
+                        "string",
+                        "null"
+                      ],
+                      "description": "Register name (case-insensitive)."
+                    },
+                    "id": {
+                      "type": [
+                        "integer",
+                        "null"
+                      ],
+                      "description": "Register id.",
+                      "minimum": 0
+                    }
+                  },
+                  "additionalProperties": false
+                }
+              }
+            },
+            "required": [
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Write register values.",
+            "properties": {
+              "op": {
+                "const": "set_registers"
+              },
+              "memspace": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "VICE memory space (0=CPU, 1=Drive8, etc.).",
+                "minimum": 0,
+                "maximum": 4
+              },
+              "writes": {
+                "type": "array",
+                "description": "Register writes to apply.",
+                "items": {
+                  "type": "object",
+                  "description": "Register write descriptor.",
+                  "properties": {
+                    "name": {
+                      "type": [
+                        "string",
+                        "null"
+                      ],
+                      "description": "Register name (case-insensitive)."
+                    },
+                    "id": {
+                      "type": [
+                        "integer",
+                        "null"
+                      ],
+                      "description": "Register id.",
+                      "minimum": 0
+                    },
+                    "value": {
+                      "type": "integer",
+                      "description": "Value to write.",
+                      "minimum": 0
+                    }
+                  },
+                  "required": [
+                    "value"
+                  ],
+                  "additionalProperties": false
+                },
+                "minItems": 1
+              }
+            },
+            "required": [
+              "op",
+              "writes"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Single-step CPU execution.",
+            "properties": {
+              "op": {
+                "const": "step"
+              },
+              "count": {
+                "type": [
+                  "integer",
+                  "null"
+                ],
+                "description": "Number of instructions to step.",
+                "minimum": 1,
+                "default": 1
+              },
+              "mode": {
+                "type": [
+                  "string",
+                  "null"
+                ],
+                "description": "Step mode (into or over).",
+                "enum": [
+                  "into",
+                  "over"
+                ]
+              }
+            },
+            "required": [
+              "op"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Continue execution until the current routine returns.",
+            "properties": {
+              "op": {
+                "const": "step_return"
+              }
+            },
+            "required": [
+              "op"
+            ],
+            "additionalProperties": false
+          }
+        ],
+        "discriminator": {
+          "propertyName": "op"
+        }
+      },
+      "_meta": {
+        "domain": "debug",
+        "summary": "Manage breakpoints, inspect registers, and step through code on the VICE backend.",
+        "lifecycle": "request-response",
+        "resources": [
+          "c64://specs/assembly",
+          "c64://specs/memory-map"
+        ],
+        "prompts": [
+          "assembly-program",
+          "memory-debug"
+        ],
+        "examples": [
+          {
+            "name": "List checkpoints",
+            "description": "Show all breakpoints defined in the emulator.",
+            "arguments": {
+              "op": "list_checkpoints"
+            }
+          },
+          {
+            "name": "Step over instruction",
+            "description": "Advance one instruction without entering subroutines.",
+            "arguments": {
+              "op": "step",
+              "mode": "over"
+            }
+          },
+          {
+            "name": "Inspect registers",
+            "description": "Read CPU registers from memspace 0 (default).",
+            "arguments": {
+              "op": "get_registers"
+            }
+          }
+        ],
+        "tags": [
+          "debug",
+          "vice",
+          "breakpoint",
+          "registers",
+          "grouped"
+        ],
+        "workflowHints": [
+          "Use debugger tools after pausing execution so memory and screen reads remain stable.",
+          "Communicate breakpoint effects clearly and restore original state when toggling them."
+        ],
+        "platforms": [
+          "vice"
+        ]
+      }
+    },
+    {
+      "name": "c64_vice",
+      "title": "Reads or updates selected VICE resources that are safe to expose through MCP.",
+      "description": "Grouped entry point for reading and updating selected VICE resources.",
+      "inputSchema": {
+        "type": "object",
+        "description": "VICE emulator operations available via the c64_vice tool.",
+        "oneOf": [
+          {
+            "type": "object",
+            "description": "Read a VICE configuration resource (safe prefixes only).",
+            "properties": {
+              "op": {
+                "const": "resource_get"
+              },
+              "name": {
+                "type": "string",
+                "description": "VICE resource name (example: SidEngine, C64Model).",
+                "minLength": 1,
+                "maxLength": 64,
+                "pattern": "^[A-Z][A-Za-z0-9_.-]{0,63}$"
+              }
+            },
+            "required": [
+              "op",
+              "name"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Write a VICE configuration resource (safe prefixes only).",
+            "properties": {
+              "op": {
+                "const": "resource_set"
+              },
+              "name": {
+                "type": "string",
+                "description": "VICE resource name (example: SidEngine, C64Model).",
+                "minLength": 1,
+                "maxLength": 64,
+                "pattern": "^[A-Z][A-Za-z0-9_.-]{0,63}$"
+              },
+              "value": {
+                "description": "VICE resource value (string or integer).",
+                "oneOf": [
+                  {
+                    "type": "string"
+                  },
+                  {
+                    "type": "integer"
+                  }
+                ]
+              }
+            },
+            "required": [
+              "op",
+              "name",
+              "value"
+            ],
+            "additionalProperties": false
+          }
+        ],
+        "discriminator": {
+          "propertyName": "op"
+        }
+      },
+      "_meta": {
+        "domain": "vice",
+        "summary": "Reads or updates selected VICE resources that are safe to expose through MCP.",
+        "lifecycle": "request-response",
+        "resources": [
+          "c64://specs/memory-map"
+        ],
+        "prompts": [
+          "assembly-program",
+          "memory-debug"
+        ],
+        "examples": [
+          {
+            "name": "Read SID engine",
+            "description": "Inspect the active SID emulation mode.",
+            "arguments": {
+              "op": "resource_get",
+              "name": "SidEngine"
+            }
+          },
+          {
+            "name": "Set SID engine",
+            "description": "Switch SID emulation to resid-fp (value 2).",
+            "arguments": {
+              "op": "resource_set",
+              "name": "SidEngine",
+              "value": 2
+            }
+          }
+        ],
+        "tags": [
+          "vice",
+          "emulator",
+          "resource",
+          "grouped"
+        ],
+        "workflowHints": [
+          "Use emulator helpers when running on VICE to inspect or tweak safe runtime resources.",
+          "Explain that resource changes only persist for the current emulator session unless saved in VICE manually."
+        ],
+        "platforms": [
+          "vice"
+        ]
+      }
+    }
+  ]
+}