c64bridge 1.0.6 → 1.1.0

package/dist/tools/types.js

@@ -1,6 +1,7 @@
 import { getPlatformStatus, isPlatformSupported, setPlatform, } from "../platform.js";
 import { withDiagnosticSpan } from "../diagnostics.js";
 import { ToolUnsupportedPlatformError, ToolValidationError } from "./errors.js";
+import { annotationsForEffects } from "./access.js";
 export const OPERATION_DISCRIMINATOR = "op";
 export const VERIFY_PROPERTY_NAME = "verify";
 export const VERIFY_PROPERTY_SCHEMA = Object.freeze({
@@ -35,6 +36,7 @@ export function discriminatedUnionSchema(options) {
     // so we merge all variant properties and use an enum for the discriminator.
     const opValues = [];
     const mergedProperties = {};
+    const propertyVariants = {};
     const opDescriptions = [];
     const operationMetadata = [];
     for (const variant of variants) {
@@ -64,11 +66,14 @@ export function discriminatedUnionSchema(options) {
         for (const [key, propSchema] of Object.entries(variantProps)) {
             if (key === discriminator)
                 continue;
-            if (!mergedProperties[key]) {
-                mergedProperties[key] = propSchema;
-            }
+            (propertyVariants[key] ?? (propertyVariants[key] = [])).push(propSchema);
         }
     }
+    // Variants may declare the same property with different limits. The flattened
+    // property must accept every variant's values; per-op validation stays strict.
+    for (const [key, schemas] of Object.entries(propertyVariants)) {
+        mergedProperties[key] = combinePropertySchemas(schemas);
+    }
     const opPropertySchema = opValues.length > 0
         ? { type: "string", enum: opValues, description: `Selects the operation.` }
         : { type: "string", description: `Selects the operation.` };
@@ -92,6 +97,170 @@ export function discriminatedUnionSchema(options) {
     };
     return schema;
 }
+/**
+ * Returns the input schema as published on the wire. The per-operation schemas in
+ * "x-c64bridge-operations" duplicate the property information of the flattened
+ * schema and roughly halve its size, so they are omitted unless a client opts in
+ * with C64BRIDGE_VERBOSE_SCHEMA=1. The registry keeps them for documentation generators.
+ */
+export function publishedInputSchema(schema, options = {}) {
+    const verbose = options.verbose ?? process.env.C64BRIDGE_VERBOSE_SCHEMA === "1";
+    if (!schema || verbose || !("x-c64bridge-operations" in schema)) {
+        return schema;
+    }
+    const { "x-c64bridge-operations": _operations, ...published } = schema;
+    return published;
+}
+const OP_LIMITS_NOTE = "Limits depend on op.";
+const WIDENABLE_KEYS = new Set([
+    "type", "description", "enum", "const", "default", "minimum", "maximum", "minLength", "maxLength",
+    "minItems", "maxItems", "pattern", "format", "items", "examples",
+]);
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== "object" || typeof b !== "object" || a === null || b === null)
+        return false;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+        return false;
+    return aKeys.every((key) => deepEqual(a[key], b[key]));
+}
+function withoutDescription(schema) {
+    const { description: _description, ...rest } = schema;
+    return rest;
+}
+function typeSet(schema) {
+    if (schema.type === undefined) {
+        return undefined;
+    }
+    const types = Array.isArray(schema.type) ? [...schema.type] : [schema.type];
+    return types;
+}
+function enumValues(schema) {
+    if (schema.enum)
+        return schema.enum;
+    if ("const" in schema)
+        return [schema.const];
+    return undefined;
+}
+function smallest(a, b) {
+    return a === undefined || b === undefined ? undefined : Math.min(a, b);
+}
+function largest(a, b) {
+    return a === undefined || b === undefined ? undefined : Math.max(a, b);
+}
+/** Returns a schema accepting everything either input accepts, or undefined when that cannot be expressed safely. */
+function widenPair(a, b) {
+    const aRecord = a;
+    const bRecord = b;
+    for (const key of new Set([...Object.keys(aRecord), ...Object.keys(bRecord)])) {
+        if (!WIDENABLE_KEYS.has(key) && !deepEqual(aRecord[key], bRecord[key])) {
+            return undefined;
+        }
+    }
+    const aTypes = typeSet(a);
+    const bTypes = typeSet(b);
+    let types;
+    if (aTypes && bTypes) {
+        types = Array.from(new Set([...aTypes, ...bTypes]));
+        if (types.includes("number")) {
+            types = types.filter((type) => type !== "integer");
+        }
+    }
+    // Structured types only widen when their element schema widens.
+    let items;
+    if (a.items !== undefined || b.items !== undefined) {
+        if (!a.items || !b.items || Array.isArray(a.items) || Array.isArray(b.items)) {
+            if (!deepEqual(a.items, b.items))
+                return undefined;
+            items = a.items;
+        }
+        else {
+            items = combinePropertySchemas([a.items, b.items], false);
+        }
+    }
+    const aEnum = enumValues(a);
+    const bEnum = enumValues(b);
+    const enumUnion = aEnum && bEnum
+        ? [...aEnum, ...bEnum.filter((value) => !aEnum.includes(value))]
+        : undefined;
+    const minimum = smallest(a.minimum, b.minimum);
+    const maximum = largest(a.maximum, b.maximum);
+    const minLength = smallest(a.minLength, b.minLength);
+    const maxLength = largest(a.maxLength, b.maxLength);
+    const minItems = smallest(a.minItems, b.minItems);
+    const maxItems = largest(a.maxItems, b.maxItems);
+    const result = {};
+    for (const [key, value] of Object.entries(a)) {
+        if (!WIDENABLE_KEYS.has(key))
+            result[key] = value;
+    }
+    if (types)
+        result.type = types.length === 1 ? types[0] : types;
+    if (a.description !== undefined || b.description !== undefined)
+        result.description = a.description ?? b.description;
+    if (enumUnion)
+        result.enum = enumUnion;
+    if (minimum !== undefined)
+        result.minimum = minimum;
+    if (maximum !== undefined)
+        result.maximum = maximum;
+    if (minLength !== undefined)
+        result.minLength = minLength;
+    if (maxLength !== undefined)
+        result.maxLength = maxLength;
+    if (minItems !== undefined)
+        result.minItems = minItems;
+    if (maxItems !== undefined)
+        result.maxItems = maxItems;
+    if (items)
+        result.items = items;
+    if (a.pattern !== undefined && a.pattern === b.pattern)
+        result.pattern = a.pattern;
+    if (a.format !== undefined && a.format === b.format)
+        result.format = a.format;
+    if (deepEqual(a.default, b.default) && a.default !== undefined)
+        result.default = a.default;
+    if (deepEqual(a.examples, b.examples) && a.examples !== undefined)
+        result.examples = a.examples;
+    return result;
+}
+/**
+ * Combines the schemas that different operations declare for one property into a
+ * single schema accepting all of their values. Identical schemas are returned untouched.
+ */
+export function combinePropertySchemas(schemas, annotate = true) {
+    const first = schemas[0];
+    const distinct = [];
+    for (const schema of schemas) {
+        if (!distinct.some((existing) => deepEqual(withoutDescription(existing), withoutDescription(schema)))) {
+            distinct.push(schema);
+        }
+    }
+    if (distinct.length === 1) {
+        return first;
+    }
+    let merged = distinct[0];
+    for (const schema of distinct.slice(1)) {
+        merged = merged ? widenPair(merged, schema) : undefined;
+    }
+    const result = merged ?? {
+        anyOf: distinct.map(withoutDescription),
+        ...(first.description ? { description: first.description } : {}),
+    };
+    if (!annotate) {
+        return result;
+    }
+    const description = result.description;
+    if (description?.includes(OP_LIMITS_NOTE)) {
+        return result;
+    }
+    return { ...result, description: description ? `${description} ${OP_LIMITS_NOTE}` : OP_LIMITS_NOTE };
+}
 export function createOperationDispatcher(toolName, handlers) {
     const allowed = Object.keys(handlers).sort();
     return async (args, ctx) => {
@@ -107,7 +276,7 @@ export function createOperationDispatcher(toolName, handlers) {
         // Own properties only: "constructor", "toString", etc. must not resolve to Object.prototype members.
         const handler = hasOwnKey(handlers, opKey) ? handlers[opKey] : undefined;
         if (!handler) {
-            throw new ToolValidationError(`${toolName} does not support ${OPERATION_DISCRIMINATOR} "${opValue}"`, { path: `$.${OPERATION_DISCRIMINATOR}`, details: { allowed } });
+            throw new ToolValidationError(`${toolName} does not support ${OPERATION_DISCRIMINATOR} "${opValue}"`, { path: `$.${OPERATION_DISCRIMINATOR}`, details: { allowed, received: opValue } });
         }
         return handler(record, ctx);
     };
@@ -145,25 +314,40 @@ export function defineToolModule(config) {
                     ...(prerequisites ? { prerequisites } : {}),
                     ...(platforms ? { platforms } : {}),
                     ...(tool.operationPlatforms ? { operationPlatforms: tool.operationPlatforms } : {}),
+                    ...(tool.operationEffects ? { operationEffects: tool.operationEffects } : {}),
+                    ...(tool.effect ? { effect: tool.effect } : {}),
                 };
+                const declaredEffects = tool.operationEffects ? Object.values(tool.operationEffects) : tool.effect ? [tool.effect] : [];
                 return {
                     name: tool.name,
                     description: tool.description,
-                    inputSchema: tool.inputSchema,
+                    inputSchema: tagOperations(tool.inputSchema, tool.operationPlatforms, tool.operationEffects),
+                    annotations: annotationsForEffects(declaredEffects),
                     metadata,
                 };
             });
         },
+        effectOf(name, args) {
+            const tool = toolMap.get(name);
+            return tool ? resolveToolEffect(tool, args) : undefined;
+        },
         async invoke(name, args, ctx) {
             const tool = toolMap.get(name);
             if (!tool) {
-                throw new Error(`Unknown tool: ${name}`);
+                throw new ToolValidationError(`Unknown tool: ${name}`, {
+                    path: "$.name",
+                    details: { allowed: Array.from(toolMap.keys()).sort(), received: name },
+                });
             }
             const platforms = resolveSupportedPlatforms(tool, args, defaultPlatforms);
             const status = ctx.platform ?? getPlatformStatus();
             const setter = ctx.setPlatform ?? setPlatform;
             if (!isPlatformSupported(status.id, platforms)) {
-                throw new ToolUnsupportedPlatformError(resolveUnsupportedToolName(name, tool, args), status.id, platforms);
+                throw new ToolUnsupportedPlatformError(resolveUnsupportedToolName(name, tool, args), status.id, platforms, {
+                    toolName: name,
+                    op: getSelectedOperation(args),
+                    configured: configuredBackends(ctx),
+                });
             }
             const enrichedCtx = {
                 ...ctx,
@@ -179,6 +363,73 @@ export function defineToolModule(config) {
         },
     };
 }
+const ALL_PLATFORMS = ["c64u", "u2", "vice"];
+/**
+ * Marks operations in the operation list of a grouped tool description: operations that are not
+ * available on every backend get their backend list and operations that are not read-only get
+ * their effect, for example "- unmount [c64u, u2] [write]: ...".
+ */
+export function tagOperations(schema, operationPlatforms, operationEffects) {
+    if (!schema?.description || (!operationPlatforms && !operationEffects)) {
+        return schema;
+    }
+    let description = schema.description;
+    const ops = new Set([...Object.keys(operationPlatforms ?? {}), ...Object.keys(operationEffects ?? {})]);
+    for (const op of ops) {
+        const platforms = ownValue(operationPlatforms, op);
+        const effect = ownValue(operationEffects, op);
+        let tags = "";
+        if (platforms && platforms.length > 0 && !ALL_PLATFORMS.every((id) => platforms.includes(id))) {
+            tags += ` [${platforms.join(", ")}]`;
+        }
+        if (effect && effect !== "read") {
+            tags += ` [${effect}]`;
+        }
+        if (!tags) {
+            continue;
+        }
+        const marker = `\n- ${op}: `;
+        if (description.includes(marker)) {
+            description = description.replace(marker, `\n- ${op}${tags}: `);
+        }
+    }
+    return description === schema.description ? schema : { ...schema, description };
+}
+function resolveToolEffect(tool, args) {
+    const op = getSelectedOperation(args);
+    const overridden = tool.effectOf?.(op, args);
+    if (overridden) {
+        return overridden;
+    }
+    if (!tool.operationEffects) {
+        // Tools without operations; an undeclared effect fails closed.
+        return tool.effect ?? "destructive";
+    }
+    if (!op) {
+        return undefined;
+    }
+    const declared = ownValue(tool.operationEffects, op);
+    if (declared) {
+        return declared;
+    }
+    const opSchema = tool.inputSchema?.properties?.[OPERATION_DISCRIMINATOR];
+    const known = opSchema?.enum?.includes(op) === true;
+    // An operation of the schema without a declared effect fails closed; an unknown name is left
+    // to the dispatcher, which reports the validation error.
+    return known ? "destructive" : undefined;
+}
+function configuredBackends(ctx) {
+    const client = ctx.client;
+    if (typeof client?.getAvailableBackends !== "function") {
+        return undefined;
+    }
+    try {
+        return client.getAvailableBackends();
+    }
+    catch {
+        return undefined;
+    }
+}
 function resolveSupportedPlatforms(tool, args, defaultPlatforms) {
     const basePlatforms = mergePlatforms(defaultPlatforms, tool.supportedPlatforms) ?? defaultPlatforms;
     const operation = getSelectedOperation(args);

package/dist/tools/vice.js

@@ -2,17 +2,7 @@ import { createOperationDispatcher, defineToolModule, discriminatedUnionSchema,
 import { literalSchema, objectSchema, stringSchema, } from "./schema.js";
 import { jsonResult, textResult } from "./responses.js";
 import { ToolError, ToolExecutionError, ToolValidationError, toolErrorResult, unknownErrorResult, } from "./errors.js";
-const RESOURCE_NAME_PATTERN = /^[A-Z][A-Za-z0-9_.-]{0,63}$/;
-const SAFE_RESOURCE_PREFIXES = [
-    "C64",
-    "Machine",
-    "Sid",
-    "VIC",
-    "VICII",
-    "CIA",
-    "Joy",
-    "Sound",
-];
+import { RESOURCE_NAME_PATTERN, resourceNameProblem } from "../vice/resourcePolicy.js";
 const resourceValueSchema = {
     jsonSchema: {
         type: ["string", "integer"],
@@ -124,6 +114,7 @@ export const viceModuleGroup = defineToolModule({
                 description: "VICE emulator operations available via the c64_vice tool.",
                 variants: viceOperationSchemas.map((schema) => schema.jsonSchema),
             }),
+            operationEffects: { resource_get: "read", resource_set: "write" },
             tags: ["vice", "resource", "grouped"],
             examples: [
                 {
@@ -148,10 +139,8 @@ function handleToolError(error) {
     return unknownErrorResult(error);
 }
 function ensureSafeResourceName(name, path) {
-    if (!RESOURCE_NAME_PATTERN.test(name)) {
-        throw new ToolValidationError("Resource names must start with an uppercase letter and use letters, numbers, dashes, underscores, or periods.", { path, details: { name } });
-    }
-    if (!SAFE_RESOURCE_PREFIXES.some((prefix) => name.startsWith(prefix))) {
-        throw new ToolValidationError(`Resource name must start with one of: ${SAFE_RESOURCE_PREFIXES.join(", ")}`, { path, details: { name } });
+    const problem = resourceNameProblem(name);
+    if (problem) {
+        throw new ToolValidationError(problem.message, { path, details: { name } });
     }
 }

package/dist/vicBitmap.js

@@ -6,7 +6,7 @@ const COLOR_RAM_BYTE_LENGTH = 1000;
 const COLOR_RAM_ADDRESS = 0xD800;
 const CHAR_ROM_SHADOW_OFFSET = 0x1000;
 const CHAR_ROM_SHADOW_LENGTH = 0x1000;
-const VIC_PALETTE = [
+export const VIC_PALETTE = [
     [0x00, 0x00, 0x00],
     [0xFF, 0xFF, 0xFF],
     [0x81, 0x33, 0x38],

package/dist/vice/mockServer.js

@@ -34,6 +34,8 @@ export class ViceMockServer {
         this.server = null;
         this.memory = new Uint8Array(0x10000);
         this.helloReady = false;
+        /** Test hook: the payload of every keyboard feed command received, in order. */
+        this.keyboardFeeds = [];
         this.heartbeat = null;
         this.checkpoints = new Map();
         this.nextCheckpointId = 1;
@@ -241,6 +243,7 @@ export class ViceMockServer {
             }
             case 0x72: { // keyboard feed
                 const len = body[0] ?? 0;
+                this.keyboardFeeds.push(Buffer.from(body.subarray(1, 1 + len)));
                 const text = body.subarray(1, 1 + len).toString("ascii").toUpperCase();
                 if (text.includes("RUN")) {
                     this.renderHello();

package/dist/vice/process.js

@@ -185,7 +185,26 @@ export async function terminateProcess(child, signal = "SIGTERM", timeoutMs = 10
     catch { }
     await waitForExit(child, timeoutMs);
 }
+/**
+ * Rejects when something already listens on the monitor address. waitForPort
+ * succeeds against any listener, so without this check a foreign process on
+ * the port would be taken for the new emulator's monitor.
+ */
+export async function assertMonitorPortFree(host, port) {
+    if (!Number.isInteger(port) || port <= 0)
+        return;
+    await new Promise((resolve, reject) => {
+        const probe = net.connect({ host, port });
+        probe.setTimeout(500, () => probe.destroy(new Error("timeout")));
+        probe.once("connect", () => {
+            probe.destroy();
+            reject(new Error(`Cannot start VICE: port ${port} on ${host} is already in use by another process. Stop it or configure a different vice.port.`));
+        });
+        probe.once("error", () => resolve()); // refused or unreachable: nothing is listening
+    });
+}
 export async function startViceProcess(options) {
+    await assertMonitorPortFree(options.host, options.port);
     const debugEnabled = process.env.VICE_DEVICE_TEST_DEBUG === "1";
     // When headless=true, skip Xvfb entirely and rely on VICE's own -headless flag (VICE 3.5+).
     const useHeadless = options.headless === true || process.env.VICE_HEADLESS === "1";

package/dist/vice/resourcePolicy.js

@@ -0,0 +1,36 @@
+/**
+ * Which VICE resources may be read or written through the MCP tools.
+ * Shared by c64_vice and by c64_config on the VICE backend, so neither path
+ * can reach a resource the other refuses (several VICE resources hold host
+ * file names).
+ */
+export const RESOURCE_NAME_PATTERN = /^[A-Z][A-Za-z0-9_.-]{0,63}$/;
+export const SAFE_RESOURCE_PREFIXES = [
+    "C64",
+    "Machine",
+    "Sid",
+    "VIC",
+    "VICII",
+    "CIA",
+    "Joy",
+    "Sound",
+    "Warp", // WarpMode: a plain on/off switch
+];
+/** Resources that name host files or directories, even under a safe prefix (for example SoundRecordDeviceArg). */
+const HOST_FILE_RESOURCE_PATTERN = /(File|Image|Dir|Directory|Path|Arg|Name)\d*$/;
+/** Returns why a resource name is refused, or undefined when it is allowed. */
+export function resourceNameProblem(name) {
+    if (!RESOURCE_NAME_PATTERN.test(name)) {
+        return {
+            kind: "pattern",
+            message: "Resource names must start with an uppercase letter and use letters, numbers, dashes, underscores, or periods.",
+        };
+    }
+    if (!SAFE_RESOURCE_PREFIXES.some((prefix) => name.startsWith(prefix))) {
+        return { kind: "prefix", message: `Resource name must start with one of: ${SAFE_RESOURCE_PREFIXES.join(", ")}` };
+    }
+    if (HOST_FILE_RESOURCE_PATTERN.test(name)) {
+        return { kind: "host_file", message: `Resource '${name}' refers to a host file or directory and cannot be accessed through this tool.` };
+    }
+    return undefined;
+}

package/dist/vice/viceClient.js

@@ -2,6 +2,8 @@
  * VICE Binary Monitor client with debugger, resource, and display helpers.
  */
 import net from "node:net";
+/** How long a TCP connect to the monitor may take before it is abandoned. */
+export const VICE_CONNECT_TIMEOUT_MS = 5000;
 export class ViceClient {
     constructor() {
         this.buffer = Buffer.alloc(0);
@@ -12,16 +14,27 @@ export class ViceClient {
     setUnsolicitedHandler(handler) {
         this.onUnsolicitedHandler = handler;
     }
-    async connect(port, host = "127.0.0.1") {
-        this.socket = net.connect({ host, port });
+    async connect(port, host = "127.0.0.1", options = {}) {
+        const timeoutMs = options.connectTimeoutMs ?? VICE_CONNECT_TIMEOUT_MS;
+        this.socket = options.socketFactory ? options.socketFactory(host, port) : net.connect({ host, port });
         this.closing = false;
         this.socket.setNoDelay(true);
         await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                // A host that drops the SYN would otherwise block until the OS gives up.
+                this.socket.off("connect", onConnect);
+                this.socket.off("error", onError);
+                this.socket.on("error", () => { }); // destroy() may still emit an error
+                this.socket.destroy();
+                reject(new Error(`Timed out after ${timeoutMs} ms connecting to the VICE monitor at ${host}:${port}`));
+            }, timeoutMs);
             const onConnect = () => {
+                clearTimeout(timer);
                 this.socket.off("error", onError);
                 resolve();
             };
             const onError = (error) => {
+                clearTimeout(timer);
                 this.socket.off("connect", onConnect);
                 reject(error);
             };
@@ -212,10 +225,14 @@ export class ViceClient {
     }
     async keyboardFeed(text) {
         if (!text)
-            return;
+            throw new Error("keyboardFeed requires non-empty text");
         const bytes = Buffer.from(text, "ascii");
-        const body = Buffer.concat([Buffer.from([bytes.length & 0xff]), bytes]);
-        await this.send(0x72, body);
+        // The command carries its length in one byte, so longer text goes out as
+        // consecutive commands, in order.
+        for (let offset = 0; offset < bytes.length; offset += 255) {
+            const chunk = bytes.subarray(offset, offset + 255);
+            await this.send(0x72, Buffer.concat([Buffer.from([chunk.length]), chunk]));
+        }
     }
     /** Set the VICE joyport's active-low control byte (BM command 0xA2). */
     async joyportSet(port, activeLowMask) {

package/doc/vice/support-matrix.md

@@ -21,15 +21,18 @@ This document is the source of truth for VICE support in the public MCP surface.
 
 | Tool | Operations |
 | --- | --- |
-| `c64_program` | `run_prg`, `upload_run_basic`, `upload_run_asm`, `batch_run` |
-| `c64_memory` | `read`, `read_screen`, `wait_for_text`, `write` |
-| `c64_system` | `reset`, `reboot`, `poweroff`, `start_task`, `stop_task`, `stop_all_tasks`, `list_tasks` |
-| `c64_graphics` | `render_petscii_art`, `render_bitmap`, `render_sprite`, `render_petscii_text` |
+| `c64_program` | `load_prg`, `run_prg`, `upload_run_basic`, `upload_run_asm`, `batch_run`, `bundle_run`, `cross_platform_greeting` |
+| `c64_memory` | `read`, `write`, `read_screen`, `wait_for_text`, `list_basic`, `disassemble`, `copy_memory`, `fill_memory`, `search_memory`, `compare_memory`, `save_memory` |
+| `c64_system` | `reset`, `reboot`, `poweroff`, `power_cycle`, `start_task`, `stop_task`, `stop_all_tasks`, `list_tasks`, `performance_report` |
+| `c64_graphics` | `capture_frame`, `render_petscii_art`, `render_bitmap`, `render_sprite`, `render_petscii_text`, `get_display_state` |
 | `c64_rag` | `basic`, `asm` |
-| `c64_disk` | `list_drives`, `mount`, `unmount` |
+| `c64_disk` | `list_drives`, `mount` |
 | `c64_drive` | `reset`, `power_on`, `power_off`, `set_mode` |
 | `c64_config` | `list`, `get`, `set`, `batch_update`, `info`, `version`, `snapshot`, `restore`, `diff` |
-| `c64_sound` | `set_volume`, `reset`, `note_on`, `note_off`, `silence_all`, `generate`, `compile_play` |
+| `c64_sound` | `set_volume`, `reset`, `note_on`, `note_off`, `silence_all`, `generate`, `compile_play`, `play_preset`, `pipeline`, `analyze`, `record_analyze` |
+| `c64_input` | `write_text`, `key`, `joystick` |
+| `c64_extract` | `sprites`, `charset`, `memory_dump`, `firmware_health` |
+| `c64_select_backend` | `select` |
 | `c64_debug` | all operations |
 | `c64_vice` | all operations |
 
@@ -37,15 +40,18 @@ This document is the source of truth for VICE support in the public MCP surface.
 
 | Tool | Operations |
 | --- | --- |
-| `c64_program` | `load_prg`, `run_crt`, `bundle_run` |
-| `c64_disk` | `file_info`, `create_image`, `find_and_run` |
+| `c64_program` | `run_crt` |
+| `c64_disk` | `unmount`, `file_info`, `create_image`, `find_and_run`, `find_paths` |
 | `c64_drive` | `load_rom` |
-| `c64_sound` | `play_sid_file`, `play_mod_file`, `pipeline`, `analyze`, `record_analyze` |
+| `c64_sound` | `capture_samples`, `play_sid_file`, `play_mod_file` |
 | `c64_config` | `load_flash`, `save_flash`, `reset_defaults`, `read_debugreg`, `write_debugreg`, `shuffle` |
-| `c64_system` | `pause`, `resume`, `menu` |
+| `c64_system` | `pause`, `resume`, `menu`, `read_menu_screen` |
+| `c64_input` | `keyboard`, `release_all`, `state` |
+| `c64_extract` | `fs_stats` |
 | `c64_stream` | all operations |
 | `c64_printer` | all operations |
-| `c64_extract` | all operations |
+
+The per-operation support is declared in `src/tools/registry/*.ts` (`operationPlatforms` and `supportedPlatforms`); the generated tables in `README.md` and `mcp/*.json` reflect it. If this file and the registry differ, the registry is correct.
 
 ## Notes
 

package/mcp/schemas/c64_batch.schema.json

@@ -34,7 +34,8 @@
         ],
         "additionalProperties": false
       },
-      "minItems": 1
+      "minItems": 1,
+      "maxItems": 64
     },
     "stopOnError": {
       "type": [