@henols/vice-mcp 0.2.2 → 0.2.4

package/tools-manifest.stock.json

@@ -3440,7 +3440,7 @@
     },
     {
       "name": "vice_run_until",
-      "description": "Run until an address is reached. \"cycles\" is NOT implemented on stock and is refused whenever present, including alongside \"address\" (it used to be silently dropped while the answer still said reached:true); unexpected argument names are refused by name too. timeout_ms (stock-only) bounds the wait; an address that never executes returns a timedOut answer rather than hanging. machineHalted is stamped on every answer (never omitted, so an absent field can never be read as false) and is DERIVED, not asserted: true on a hit and on a timeout whose cleanup CHECKPOINT_DELETE was answered over a live socket, false when that delete failed or the socket is gone and the run-state projection does not say stopped. machineHalted false means the state could not be established, NOT that the machine is running -- machineHaltedNote says which case applies and names vice_execution_run (halted) or vice_diagnose (unestablished) as the next call. A timed-out wait racing its own cleanup CHECKPOINT_DELETE against a fired-but-unreported checkpoint is resolved from a live program-counter read: raceResolved is pc_at_address (confirmed reached), pc_elsewhere (confirmed not reached), or unresolved (the PC read itself failed, in which case reached is omitted entirely and reachedUnknown is true rather than asserting a guessed value either way).",
+      "description": "Run until an address is reached. \"cycles\" is NOT implemented on stock and is refused whenever present, including alongside \"address\" (it used to be silently dropped while the answer still said reached:true); unexpected argument names are refused by name too. timeout_ms (stock-only) bounds the wait; an address that never executes returns a timedOut answer rather than hanging. machineHalted is stamped on every answer (never omitted, so an absent field can never be read as false) and is DERIVED, not asserted: true on a hit and on a timeout whose cleanup CHECKPOINT_DELETE was answered over a live socket, false when that delete failed or the socket is gone and the run-state projection does not say stopped. machineHalted false means the state could not be established, NOT that the machine is running -- machineHaltedNote says which case applies and names vice_execution_run (halted) or vice_diagnose (unestablished) as the next call. A timed-out wait racing its own cleanup CHECKPOINT_DELETE against a fired-but-unreported checkpoint is resolved from a live program-counter read: raceResolved is pc_at_address (confirmed reached), pc_elsewhere (confirmed not reached), or unresolved (the PC read itself failed, in which case reached is omitted entirely and reachedUnknown is true rather than asserting a guessed value either way). reproducible (stock-only, absent by default) runs the whole reproducible-run protocol instead of the ordinary path -- arm the frame anchor and the target while halted, monitor-issued hard RESET, exactly one resume, then an event-driven wait on the target checkpoint's own id -- and answers with the four-term stop identity (pc, hitCount, line, cycle), where hitCount is the FRAME ANCHOR's count and targetHitCount is the target's own. It is a whole-procedure switch with no sub-flags (there is no skip_reset, no_anchor or reset_only, so a protocol-without-the-reset is not a callable option) and it REFUSES rather than degrades: reproducible: true without frame_anchor is refused naming why the frame term cannot otherwise be supplied, frame_anchor without reproducible is refused rather than accepted and ignored, and a build whose REGISTERS_AVAILABLE enumerates no PC/LIN/CYC is refused before anything is armed.",
       "inputSchema": {
         "type": "object",
         "properties": {
@@ -3455,6 +3455,14 @@
           "timeout_ms": {
             "type": "number",
             "description": "Stock-only. Milliseconds to wait for the address to be reached before giving up; default 30000, clamped to a ceiling of 600000."
+          },
+          "reproducible": {
+            "type": "boolean",
+            "description": "Stock-only. Absent by default. When true, runs the reproducible-run protocol (REPRO-02) rather than the ordinary run-until path: the frame anchor and the target are armed while the machine is halted, a monitor-issued hard RESET is issued, exactly ONE resume is sent, and the wait resolves on the target checkpoint's own CHECKPOINT_INFO. Requires frame_anchor. A whole-procedure switch, never composable sub-flags -- there is no skip_reset, no_anchor or reset_only, because a shipped protocol-without-the-reset would be exactly the second route a caller can forget it took. Must be a boolean; a string is refused rather than coerced, since the string \"false\" is truthy."
+          },
+          "frame_anchor": {
+            "type": "string",
+            "description": "Stock-only. Absent by default, and REQUIRED whenever reproducible is true -- an address (number, hex, or symbol) of a site executed once per frame, whose hit count IS the frame term of the stop identity (PC, hit_count, (LIN, CYC)). No default is supplied and none would be safe to guess: the once-per-frame site is release-specific, and a cracked release almost always takes over the IRQ, so a KERNAL site such as $EA31 may never execute at all. Omitting it with reproducible: true is REFUSED rather than degraded to a two-term identity -- (LIN, CYC) is a within-frame position, not a monotonic clock, so without the frame term two stops one whole frame apart certify as the same stop. Supplying it WITHOUT reproducible is also refused, rather than accepted and ignored. May equal address: the procedure still arms two distinct checkpoints (the anchor non-temporary, the target temporary) and waits on the target's own id."
           }
         }
       },
@@ -3527,6 +3535,72 @@
           },
           "raceNote": {
             "type": "string"
+          },
+          "protocol": {
+            "type": "string"
+          },
+          "reproducibleStop": {
+            "type": "boolean"
+          },
+          "reproducibleStopNote": {
+            "type": "string"
+          },
+          "frameAnchor": {
+            "type": "number"
+          },
+          "targetCheckpointId": {
+            "type": "number"
+          },
+          "anchorCheckpointId": {
+            "type": "number"
+          },
+          "targetHitCount": {
+            "type": "number"
+          },
+          "anchorHitsObserved": {
+            "type": "number"
+          },
+          "anchorHitCountObserved": {
+            "type": "number"
+          },
+          "anchorStoppedFirst": {
+            "type": "boolean"
+          },
+          "anchorStoppedFirstNote": {
+            "type": "string"
+          },
+          "anchorCleanup": {
+            "type": "string"
+          },
+          "anchorCleanupError": {
+            "type": "string"
+          },
+          "cleanupNote": {
+            "type": "string"
+          },
+          "pc": {
+            "type": "number"
+          },
+          "line": {
+            "type": "number"
+          },
+          "cycle": {
+            "type": "number"
+          },
+          "hitCountNote": {
+            "type": "string"
+          },
+          "stopIdentityTerms": {
+            "type": "array"
+          },
+          "stopIdentityNote": {
+            "type": "string"
+          },
+          "resumes": {
+            "type": "number"
+          },
+          "resumesNote": {
+            "type": "string"
           }
         },
         "required": [
@@ -3540,7 +3614,7 @@
     },
     {
       "name": "vice_diagnose",
-      "description": "Read-mostly. Answers which of five states this session's emulator is in on the stock backend -- restarted, checkpoint_trap, wedged, monitor_held_elsewhere, or live -- with the evidence that produced the verdict. The fork's sixth verdict, naming a stale-versus-fresh read distinction, is absent on stock: every stock read pauses the machine uniformly, so that distinction is unreachable by construction. It may resume the machine once or twice to measure a cycle bracket, so it is never something to call reflexively; when it runs a bracket it leaves the machine PAUSED afterward -- resuming is your own next call. A \"checkpoint_trap\" verdict means the machine stopped ITSELF at an armed checkpoint and must NOT be recycled -- recycling a self-inflicted stop destroys a healthy instance. \"monitor_held_elsewhere\" means a different client already holds this instance's single binary-monitor slot -- the instance is healthy, just claimed elsewhere. machinePaused is derived from the emulator's own observed run state, never hand-passed; machinePausedSource says whether that derivation was a direct wire observation of a STOPPED/JAM event agreeing with this path's own halting reads (\"observed\"), inferred because no session was ever obtained (\"no_session\"), or inferred (\"structural\") -- which covers both an unknown run state AND a run state reading of \"running\", since every path reaching a verdict has already sent a halting read, so \"running\" contradicts this path's own reads rather than observing the machine. machinePaused is therefore never false for a session that reached a verdict. evidence.jamObserved is always present (never omitted) and is true once a JAM (0x61) event has arrived on this instance's wire: the 6510 hit an illegal opcode and the CPU is dead REGARDLESS of the verdict. Recover with vice_machine_reset, NOT vice_recycle -- recycling destroys an instance a reset would have fixed. With -jamaction 2 a jam reads as wedged (both brackets zero advance); with the default jamaction the emulator keeps burning cycles refetching the same opcode, so both brackets ADVANCE and it reads as live. Neither is a wedge, and jamObserved is the only thing that tells them apart. EVERY answer that establishes no verdict at all -- with no exception left -- is isError:true with text beginning \"vice_diagnose: diagnosis_unavailable (<reason>)\", for one of: protocol_decode_failure, connection_lost, request_timeout, monitor_acquisition_timeout, session_refused, evidence_gathering_failed, liveness_unmeasurable, unknown. liveness_unmeasurable is the expected outcome on a stock 3.9-class build (no CPUHISTORY_GET and no LIN/CYC enumerated): the bracket could not be MEASURED, which is not the same as measuring zero advance and is never a wedge. That outcome is deliberately NOT one of the five verdicts above -- it means the machine's state is UNKNOWN, not live, wedged, or anything else, and is never on its own grounds a reason to call vice_recycle.",
+      "description": "Read-mostly. Answers which of five states this session's emulator is in on the stock backend -- restarted, checkpoint_trap, wedged, monitor_held_elsewhere, or live -- with the evidence that produced the verdict. The fork's sixth verdict, naming a stale-versus-fresh read distinction, is absent on stock: every stock read pauses the machine uniformly, so that distinction is unreachable by construction. It may resume the machine once or twice to measure a cycle bracket, so it is never something to call reflexively; when it runs a bracket it leaves the machine PAUSED afterward -- resuming is your own next call. A \"checkpoint_trap\" verdict means the machine stopped ITSELF at an armed checkpoint and must NOT be recycled -- recycling a self-inflicted stop destroys a healthy instance. \"monitor_held_elsewhere\" means a different client already holds this instance's single binary-monitor slot -- the instance is healthy, just claimed elsewhere. machinePaused is derived from the emulator's own observed run state, never hand-passed; machinePausedSource says whether that derivation was a direct wire observation of a STOPPED/JAM event agreeing with this path's own halting reads (\"observed\"), inferred because no session was ever obtained (\"no_session\"), or inferred (\"structural\") -- which covers both an unknown run state AND a run state reading of \"running\", since every path reaching a verdict has already sent a halting read, so \"running\" contradicts this path's own reads rather than observing the machine. machinePaused is therefore never false for a session that reached a verdict. evidence.jamObserved is always present (never omitted) and is true once a JAM (0x61) event has arrived on this instance's wire: the 6510 hit an illegal opcode and the CPU is dead REGARDLESS of the verdict. Recover with vice_machine_reset, NOT vice_recycle -- recycling destroys an instance a reset would have fixed. With -jamaction 2 a jam reads as wedged (both brackets zero advance); with the default jamaction the emulator keeps burning cycles refetching the same opcode, so both brackets ADVANCE and it reads as live. Neither is a wedge, and jamObserved is the only thing that tells them apart. evidence.channelContention is always present (never omitted); when held is true the OTHER monitor channel (stock's binary and -remotemonitor text channels) holds this instance's halt authority, the verdict is live, bracketsRun is 0 because no bracket was run at all, and the instance is healthy -- never a reason to recycle; wait for the other channel's operation to finish, or find its holder. channelContention.channel/operation/grantId/heldMs name the holder's channel, operation, grant id (the literal \"unknown\" when the holder carries none) and hold duration in whole milliseconds when held is true, and are null -- never omitted, never 0 for heldMs -- when held is false. EVERY answer that establishes no verdict at all -- with no exception left -- is isError:true with text beginning \"vice_diagnose: diagnosis_unavailable (<reason>)\", for one of: protocol_decode_failure, connection_lost, request_timeout, monitor_acquisition_timeout, session_refused, evidence_gathering_failed, liveness_unmeasurable, unknown. liveness_unmeasurable is the expected outcome on a stock 3.9-class build (no CPUHISTORY_GET and no LIN/CYC enumerated): the bracket could not be MEASURED, which is not the same as measuring zero advance and is never a wedge. That outcome is deliberately NOT one of the five verdicts above -- it means the machine's state is UNKNOWN, not live, wedged, or anything else, and is never on its own grounds a reason to call vice_recycle.",
       "inputSchema": {
         "type": "object",
         "additionalProperties": false
@@ -3566,10 +3640,30 @@
             "properties": {
               "jamObserved": {
                 "type": "boolean"
+              },
+              "channelContention": {
+                "type": "object",
+                "properties": {
+                  "held": {
+                    "type": "boolean"
+                  },
+                  "channel": {},
+                  "operation": {},
+                  "grantId": {},
+                  "heldMs": {}
+                },
+                "required": [
+                  "held",
+                  "channel",
+                  "operation",
+                  "grantId",
+                  "heldMs"
+                ]
               }
             },
             "required": [
-              "jamObserved"
+              "jamObserved",
+              "channelContention"
             ]
           },
           "machinePaused": {
@@ -3644,6 +3738,773 @@
           "runState"
         ]
       }
+    },
+    {
+      "name": "vice_device_console",
+      "description": "Stock-only, no fork counterpart -- reaches VICE's text monitor over the -remotemonitor channel and halts the machine for the duration of the command, exactly as a binary-monitor command does. Issues the single allowlisted verb \"device c:\", resetting the current default device (memspace) back to the main CPU. Use this after a drive checkpoint hit leaves default_memspace pointed at a drive unit -- ADVANCE_INSTRUCTIONS and EXECUTE_UNTIL_RETURN then step the wrong CPU, and a bank-qualified checkpoint condition fails outright, until this is issued. This is an explicit tool, not auto-healing: nothing on the binary-side stepping path calls it automatically.",
+      "inputSchema": {
+        "type": "object",
+        "additionalProperties": false
+      },
+      "outputSchema": {
+        "type": "object",
+        "properties": {
+          "response": {
+            "type": "string"
+          },
+          "note": {
+            "type": "string"
+          },
+          "runState": {
+            "type": "string",
+            "enum": [
+              "running",
+              "stopped",
+              "unknown"
+            ]
+          }
+        },
+        "required": [
+          "response",
+          "note",
+          "runState"
+        ]
+      }
+    },
+    {
+      "name": "vice_warp_set",
+      "description": "Stock-only, no fork counterpart -- reaches VICE's text monitor over the -remotemonitor channel and halts the machine for the duration of the command, exactly as a binary-monitor command does. Issues \"warp on\" or \"warp off\" depending on \"enabled\". There is no runtime WarpMode *resource* on stock -- measured err=0x01 OBJECT_MISSING over RESOURCE_GET -- so this is the only way to toggle warp at runtime on this backend; warp requested at launch time (-warp / InitialWarpMode) is a separate mechanism this tool does not touch. The response reports warp's own OBSERVED state rather than assuming the write took.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "enabled": {
+            "type": "boolean",
+            "description": "true issues \"warp on\", false issues \"warp off\"."
+          }
+        },
+        "required": [
+          "enabled"
+        ],
+        "additionalProperties": false
+      },
+      "outputSchema": {
+        "type": "object",
+        "properties": {
+          "requested": {
+            "type": "boolean"
+          },
+          "response": {
+            "type": "string"
+          },
+          "note": {
+            "type": "string"
+          },
+          "runState": {
+            "type": "string",
+            "enum": [
+              "running",
+              "stopped",
+              "unknown"
+            ]
+          }
+        },
+        "required": [
+          "requested",
+          "response",
+          "note",
+          "runState"
+        ]
+      }
+    },
+    {
+      "name": "vice_memmap_show",
+      "description": "Stock-only, no fork counterpart -- reaches VICE's text monitor over the -remotemonitor channel and issues the single allowlisted verb \"memmapshow\", returning a structured, adjacency-merged access map in which execute is its own bit, for both RAM and ROM, never folded into a read. \"startAddress\", \"endAddress\" and \"maxRanges\" are client-side projection filters applied AFTER parsing -- none of the three ever reaches the socket, and the dialed command is always the frozen literal \"memmapshow\". An address with no recorded access is reported only via the gap between \"addressesWithRecordedAccess\" and \"addressesQueried\" -- never rendered, named, or implied as data.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "startAddress": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 65535,
+            "description": "Inclusive lower bound of the projection filter. Defaults to 0. Applied after parsing, never sent to the text monitor."
+          },
+          "endAddress": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 65535,
+            "description": "Inclusive upper bound of the projection filter. Defaults to 65535. Applied after parsing, never sent to the text monitor."
+          },
+          "maxRanges": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 4096,
+            "description": "Hard ceiling on the number of emitted merged ranges. Defaults to 256, clamped to 4096 regardless of what is requested."
+          }
+        },
+        "additionalProperties": false
+      },
+      "outputSchema": {
+        "type": "object",
+        "properties": {
+          "command": {
+            "type": "string"
+          },
+          "identityWarning": {
+            "type": "string"
+          },
+          "ranges": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "start": {
+                  "type": "integer"
+                },
+                "end": {
+                  "type": "integer"
+                },
+                "io": {
+                  "type": "object",
+                  "properties": {
+                    "read": {
+                      "type": "boolean"
+                    },
+                    "write": {
+                      "type": "boolean"
+                    },
+                    "execute": {
+                      "type": "boolean"
+                    }
+                  },
+                  "required": [
+                    "read",
+                    "write",
+                    "execute"
+                  ]
+                },
+                "rom": {
+                  "type": "object",
+                  "properties": {
+                    "read": {
+                      "type": "boolean"
+                    },
+                    "write": {
+                      "type": "boolean"
+                    },
+                    "execute": {
+                      "type": "boolean"
+                    }
+                  },
+                  "required": [
+                    "read",
+                    "write",
+                    "execute"
+                  ]
+                },
+                "ram": {
+                  "type": "object",
+                  "properties": {
+                    "read": {
+                      "type": "boolean"
+                    },
+                    "write": {
+                      "type": "boolean"
+                    },
+                    "execute": {
+                      "type": "boolean"
+                    }
+                  },
+                  "required": [
+                    "read",
+                    "write",
+                    "execute"
+                  ]
+                },
+                "annotations": {
+                  "type": "array",
+                  "items": {
+                    "type": "string",
+                    "enum": [
+                      "dummy",
+                      "uninitialized-read",
+                      "uninitialized-exec"
+                    ]
+                  }
+                }
+              },
+              "required": [
+                "start",
+                "end",
+                "io",
+                "rom",
+                "ram",
+                "annotations"
+              ]
+            }
+          },
+          "rangeCount": {
+            "type": "integer"
+          },
+          "truncated": {
+            "type": "boolean"
+          },
+          "addressesWithRecordedAccess": {
+            "type": "integer"
+          },
+          "addressesQueried": {
+            "type": "integer"
+          },
+          "executeCounts": {
+            "type": "object",
+            "properties": {
+              "io": {
+                "type": "integer"
+              },
+              "rom": {
+                "type": "integer"
+              },
+              "ram": {
+                "type": "integer"
+              }
+            },
+            "required": [
+              "io",
+              "rom",
+              "ram"
+            ]
+          },
+          "runState": {
+            "type": "string",
+            "enum": [
+              "running",
+              "stopped",
+              "unknown"
+            ]
+          }
+        },
+        "required": [
+          "command",
+          "ranges",
+          "rangeCount",
+          "truncated",
+          "addressesWithRecordedAccess",
+          "addressesQueried",
+          "executeCounts",
+          "runState"
+        ]
+      }
+    },
+    {
+      "name": "vice_memmap_zap",
+      "description": "Stock-only, no fork counterpart -- reaches VICE's text monitor over the -remotemonitor channel and halts the machine for the duration of the command, exactly as a binary-monitor command does. Issues the single allowlisted verb \"memmapzap\", which clears the emulator's accumulated memory-access map, and then \"memmapshow\", so the returned \"addressesWithRecordedAccess\" and \"addressesQueried\" are observable proof the map was cleared, never a bare acknowledgement. Takes no parameters at all. An address with no recorded access is reported only via the gap between \"addressesWithRecordedAccess\" and \"addressesQueried\" -- never rendered, named, or implied as data.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {},
+        "additionalProperties": false
+      },
+      "outputSchema": {
+        "type": "object",
+        "properties": {
+          "command": {
+            "type": "string"
+          },
+          "identityWarning": {
+            "type": "string"
+          },
+          "addressesWithRecordedAccess": {
+            "type": "integer"
+          },
+          "addressesQueried": {
+            "type": "integer"
+          },
+          "executeCounts": {
+            "type": "object",
+            "properties": {
+              "io": {
+                "type": "integer"
+              },
+              "rom": {
+                "type": "integer"
+              },
+              "ram": {
+                "type": "integer"
+              }
+            },
+            "required": [
+              "io",
+              "rom",
+              "ram"
+            ]
+          },
+          "runState": {
+            "type": "string",
+            "enum": [
+              "running",
+              "stopped",
+              "unknown"
+            ]
+          }
+        },
+        "required": [
+          "command",
+          "addressesWithRecordedAccess",
+          "addressesQueried",
+          "executeCounts",
+          "runState"
+        ]
+      }
+    },
+    {
+      "name": "vice_cpu_history",
+      "description": "Stock-only, no fork counterpart -- reaches VICE's text monitor over the -remotemonitor channel and halts the machine for the duration of the command, exactly as a binary-monitor command does. Issues \"chis\" (or \"chis N\" for a caller-chosen decimal row count -- the ONE place that string is built, and validated/rendered there, never here), returning the decoded CPU-history entries -- address, raw bytes, disassembly, registers, processor flags and cycle count -- in the emulator's own emitted order. \"chis\" is compiled behind the same build-time flag as vice_memmap_show's \"memmapshow\"; a build without --enable-cpuhistory is reported as a named missing capability with its remedy, never a parse error.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "count": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 65535,
+            "description": "Number of most-recent history rows to request. Omitted dials the bare \"chis\" verb."
+          }
+        },
+        "additionalProperties": false
+      },
+      "outputSchema": {
+        "type": "object",
+        "properties": {
+          "command": {
+            "type": "string"
+          },
+          "identityWarning": {
+            "type": "string"
+          },
+          "entries": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "address": {
+                  "type": "integer"
+                },
+                "bytes": {
+                  "type": "array",
+                  "items": {
+                    "type": "integer"
+                  }
+                },
+                "disassembly": {
+                  "type": "string"
+                },
+                "registers": {
+                  "type": "object",
+                  "properties": {
+                    "a": {
+                      "type": "integer"
+                    },
+                    "x": {
+                      "type": "integer"
+                    },
+                    "y": {
+                      "type": "integer"
+                    },
+                    "sp": {
+                      "type": "integer"
+                    }
+                  },
+                  "required": [
+                    "a",
+                    "x",
+                    "y",
+                    "sp"
+                  ]
+                },
+                "flags": {
+                  "type": "object",
+                  "properties": {
+                    "n": {
+                      "type": "boolean"
+                    },
+                    "v": {
+                      "type": "boolean"
+                    },
+                    "unused": {
+                      "type": "boolean"
+                    },
+                    "b": {
+                      "type": "boolean"
+                    },
+                    "d": {
+                      "type": "boolean"
+                    },
+                    "i": {
+                      "type": "boolean"
+                    },
+                    "z": {
+                      "type": "boolean"
+                    },
+                    "c": {
+                      "type": "boolean"
+                    }
+                  },
+                  "required": [
+                    "n",
+                    "v",
+                    "unused",
+                    "b",
+                    "d",
+                    "i",
+                    "z",
+                    "c"
+                  ]
+                },
+                "cycles": {
+                  "type": "integer"
+                }
+              },
+              "required": [
+                "address",
+                "bytes",
+                "disassembly",
+                "registers",
+                "flags",
+                "cycles"
+              ]
+            }
+          },
+          "count": {
+            "type": "integer"
+          },
+          "runState": {
+            "type": "string",
+            "enum": [
+              "running",
+              "stopped",
+              "unknown"
+            ]
+          }
+        },
+        "required": [
+          "command",
+          "entries",
+          "count",
+          "runState"
+        ]
+      }
+    },
+    {
+      "name": "vice_profile_flat",
+      "description": "Stock-only, no fork counterpart -- reaches VICE's text monitor over the -remotemonitor channel and halts the machine for the duration of the command, exactly as a binary-monitor command does. Issues \"prof flat\" (or \"prof flat N\" for a caller-chosen decimal row count, validated/rendered by the transport's own builder), returning ranked cycle counts by address -- total and self cycles, each with a percentage -- in the emulator's own rank order (highest first). \"prof flat\" carries no build-time guard at all.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "count": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 65535,
+            "description": "Number of ranked rows to request. Omitted dials the bare \"prof flat\" verb."
+          }
+        },
+        "additionalProperties": false
+      },
+      "outputSchema": {
+        "type": "object",
+        "properties": {
+          "command": {
+            "type": "string"
+          },
+          "identityWarning": {
+            "type": "string"
+          },
+          "entries": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "totalCycles": {
+                  "type": "integer"
+                },
+                "totalPercent": {
+                  "type": "number"
+                },
+                "selfCycles": {
+                  "type": "integer"
+                },
+                "selfPercent": {
+                  "type": "number"
+                },
+                "address": {
+                  "type": "integer"
+                }
+              },
+              "required": [
+                "totalCycles",
+                "totalPercent",
+                "selfCycles",
+                "selfPercent",
+                "address"
+              ]
+            }
+          },
+          "count": {
+            "type": "integer"
+          },
+          "decimalSeparator": {
+            "type": "string",
+            "enum": [
+              ",",
+              "."
+            ]
+          },
+          "runState": {
+            "type": "string",
+            "enum": [
+              "running",
+              "stopped",
+              "unknown"
+            ]
+          }
+        },
+        "required": [
+          "command",
+          "entries",
+          "count",
+          "decimalSeparator",
+          "runState"
+        ]
+      }
+    },
+    {
+      "name": "vice_backtrace",
+      "description": "Reaches VICE's text monitor over the -remotemonitor channel and halts the machine for the duration of the command, exactly as a binary-monitor command does. Issues the bare, unparameterized \"bt\" verb -- \"depth\" never reaches the wire; it truncates the PARSED frame list client-side, since \"bt\" itself takes no wire parameter -- returning the current-PC frame plus the reconstructed JSR-chain frames in the emulator's own emitted order, each with its origin, callee, SP offset, raw bytes and disassembly. The fork advertises this same tool name over its own custom HTTP API with an UNDECLARED response shape; this stock entry's structured, declared outputSchema is the two backends' one point of difference for this shared name.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "depth": {
+            "type": "number",
+            "description": "Max stack frames to show (default: 16, max: 64). A client-side projection filter applied to the PARSED frame list -- \"bt\" itself takes no wire parameter."
+          }
+        },
+        "additionalProperties": false
+      },
+      "outputSchema": {
+        "type": "object",
+        "properties": {
+          "command": {
+            "type": "string"
+          },
+          "identityWarning": {
+            "type": "string"
+          },
+          "currentPc": {
+            "type": "object",
+            "properties": {
+              "address": {
+                "type": "integer"
+              },
+              "bytes": {
+                "type": "array",
+                "items": {
+                  "type": "integer"
+                }
+              },
+              "disassembly": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "address",
+              "bytes",
+              "disassembly"
+            ]
+          },
+          "frames": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "origin": {},
+                "callee": {
+                  "type": "integer"
+                },
+                "spOffset": {
+                  "type": "integer"
+                },
+                "address": {
+                  "type": "integer"
+                },
+                "bytes": {
+                  "type": "array",
+                  "items": {
+                    "type": "integer"
+                  }
+                },
+                "disassembly": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "origin",
+                "callee",
+                "spOffset",
+                "address",
+                "bytes",
+                "disassembly"
+              ]
+            }
+          },
+          "returnedCount": {
+            "type": "integer"
+          },
+          "totalCount": {
+            "type": "integer"
+          },
+          "truncated": {
+            "type": "boolean"
+          },
+          "runState": {
+            "type": "string",
+            "enum": [
+              "running",
+              "stopped",
+              "unknown"
+            ]
+          }
+        },
+        "required": [
+          "command",
+          "currentPc",
+          "frames",
+          "returnedCount",
+          "totalCount",
+          "truncated",
+          "runState"
+        ]
+      }
+    },
+    {
+      "name": "vice_io_registers",
+      "description": "Stock-only, no fork counterpart -- reaches VICE's text monitor over the -remotemonitor channel and halts the machine for the duration of the command, exactly as a binary-monitor command does. Issues \"io $aaaa\" for the REQUIRED \"address\" argument (the bare \"io\" verb dumps every chip; this tool decodes the chip covering exactly one address), returning the chip's 64-byte register dump, its decoded VIC-II display state, and its sprite table. Every decoded-prose line this parser does not recognise is preserved verbatim and counted, never silently dropped or mapped onto a typed field. \"io\" carries no build-time guard, but degrades per-chip at runtime with its own two fixed strings when a chip has nothing to report -- reported as a named chip fact, never mistaken for a missing build capability. The decoded display state and sprite table are VIC-II only; an address covered by another chip (e.g. CIA1, CIA2, SID) is refused by name, with its register dump reported as having read cleanly.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "address": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 65535,
+            "description": "REQUIRED. The C64 address whose covering chip is decoded."
+          }
+        },
+        "required": [
+          "address"
+        ],
+        "additionalProperties": false
+      },
+      "outputSchema": {
+        "type": "object",
+        "properties": {
+          "command": {
+            "type": "string"
+          },
+          "identityWarning": {
+            "type": "string"
+          },
+          "sections": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "chip": {
+                  "type": "string"
+                },
+                "dump": {
+                  "type": "object",
+                  "properties": {
+                    "baseAddress": {
+                      "type": "integer"
+                    },
+                    "bytes": {
+                      "type": "array",
+                      "items": {
+                        "type": "integer"
+                      }
+                    }
+                  },
+                  "required": [
+                    "baseAddress",
+                    "bytes"
+                  ]
+                },
+                "decoded": {
+                  "type": "object"
+                },
+                "sprites": {
+                  "type": "object",
+                  "properties": {
+                    "columns": {
+                      "type": "integer"
+                    },
+                    "rows": {
+                      "type": "array",
+                      "items": {
+                        "type": "object",
+                        "properties": {
+                          "label": {
+                            "type": "string"
+                          },
+                          "values": {
+                            "type": "array",
+                            "items": {
+                              "type": "string"
+                            }
+                          }
+                        },
+                        "required": [
+                          "label",
+                          "values"
+                        ]
+                      }
+                    }
+                  },
+                  "required": [
+                    "columns",
+                    "rows"
+                  ]
+                }
+              },
+              "required": [
+                "chip",
+                "dump",
+                "decoded",
+                "sprites"
+              ]
+            }
+          },
+          "unrecognisedLines": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "unrecognisedLineCount": {
+            "type": "integer"
+          },
+          "runState": {
+            "type": "string",
+            "enum": [
+              "running",
+              "stopped",
+              "unknown"
+            ]
+          }
+        },
+        "required": [
+          "command",
+          "sections",
+          "unrecognisedLines",
+          "unrecognisedLineCount",
+          "runState"
+        ]
+      }
     }
   ]
 }