c64bridge 1.0.4 → 1.0.5

package/dist/tools/audio.js

@@ -11,6 +11,7 @@ const DEFAULT_SILENCE_VERIFY_DURATION_SECONDS = 1.5;
 const DEFAULT_SILENCE_VERIFY_RMS_THRESHOLD = 0.02;
 const DEFAULT_SILENCE_VERIFY_WAIT_MS = 150;
 const generatedPlaybacks = new Set();
+let lastGeneratedPlayback = Promise.resolve();
 export function cancelGeneratedSidPlayback() {
     for (const controller of generatedPlaybacks)
         controller.abort();
@@ -317,8 +318,20 @@ function transposeNote(note, semitones) {
     const newOctave = Math.floor(midi / 12) - 1;
     return `${names[wrapped]}${newOctave}`;
 }
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+function sleep(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal?.aborted) {
+            resolve();
+            return;
+        }
+        const timer = setTimeout(done, ms);
+        function done() {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", done);
+            resolve();
+        }
+        signal?.addEventListener("abort", done, { once: true });
+    });
 }
 function shouldAutoAnalyze(request) {
     const lowered = request.toLowerCase();
@@ -825,8 +838,12 @@ export const audioModule = defineToolModule({
                     const controller = new AbortController();
                     generatedPlaybacks.add(controller);
                     const pinnedFacadePromise = ctx.client.pinFacade ? ctx.client.pinFacade() : Promise.resolve(undefined); // Pin once so a later select_backend can't retarget notes mid-arpeggio (HARD01-030).
-                    void (async () => {
+                    // A replaced sequence sends its final gate-off on voice 1; waiting for it
+                    // keeps that gate-off from cutting off this sequence's first note.
+                    const previousPlayback = lastGeneratedPlayback;
+                    lastGeneratedPlayback = (async () => {
                         try {
+                            await previousPlayback;
                             const pinnedFacade = await pinnedFacadePromise;
                             await ctx.client.sidSetVolume(8, pinnedFacade);
                             for (let i = 0; i < parsed.steps; i += 1) {
@@ -845,10 +862,14 @@ export const audioModule = defineToolModule({
                                     release: 0,
                                 }, pinnedFacade);
                                 const durationMs = parsed.preset === "expression" ? expressiveDurations[i % expressiveDurations.length] : parsed.tempoMs;
-                                await sleep(Math.max(1, Math.min(20, Math.floor(durationMs / 8)))); // Clear GATE between notes so every note retriggers ADSR.
+                                // Hold GATE for most of the note, then clear it for a short gap so the next note retriggers ADSR.
+                                const gateGapMs = Math.max(1, Math.min(20, Math.floor(durationMs / 8)));
+                                // Cancellation ends the sleep at once, so the final gate-off below follows promptly.
+                                await sleep(Math.max(0, durationMs - gateGapMs), controller.signal);
+                                if (controller.signal.aborted)
+                                    break;
                                 await ctx.client.sidNoteOff(1, pinnedFacade);
-                                if (!controller.signal.aborted)
-                                    await sleep(Math.max(0, durationMs - Math.max(1, Math.min(20, Math.floor(durationMs / 8)))));
+                                await sleep(gateGapMs, controller.signal);
                             }
                             await ctx.client.sidNoteOff(1, pinnedFacade);
                         }

package/dist/tools/debug.js

@@ -572,17 +572,17 @@ function formatAddress(value) {
 }
 function parseAddress(value, label) {
     const trimmed = value.trim();
-    let radix = 10;
-    let literal = trimmed;
-    if (trimmed.startsWith("$")) {
-        radix = 16;
-        literal = trimmed.slice(1);
+    // Anchored patterns: Number.parseInt alone would read "$08G0" as $0008.
+    let parsed = Number.NaN;
+    if (/^\$[0-9a-f]+$/i.test(trimmed)) {
+        parsed = Number.parseInt(trimmed.slice(1), 16);
     }
-    else if (trimmed.toLowerCase().startsWith("0x")) {
-        radix = 16;
-        literal = trimmed.slice(2);
+    else if (/^0x[0-9a-f]+$/i.test(trimmed)) {
+        parsed = Number.parseInt(trimmed.slice(2), 16);
+    }
+    else if (/^[0-9]+$/.test(trimmed)) {
+        parsed = Number.parseInt(trimmed, 10);
     }
-    const parsed = Number.parseInt(literal, radix);
     if (!Number.isInteger(parsed) || parsed < 0 || parsed > 0xffff) {
         throw new ToolValidationError(`Invalid ${label}`, { path: `$.${label}` });
     }

package/dist/tools/errors.js

@@ -44,10 +44,21 @@ export function toolErrorResult(error) {
         ...(error.code !== undefined ? { code: error.code } : {}),
         ...(error.details !== undefined ? { details: error.details } : {}),
     };
-    const message = error.path ? `${error.message} (at ${error.path})` : error.message;
+    const located = error.path ? `${error.message} (at ${error.path})` : error.message;
+    // Clients often show only the text content, so surface the underlying cause
+    // (for example a range check or firmware error string) next to the summary.
+    const detailMessage = describeDetailMessage(error.details);
+    const message = detailMessage && !located.includes(detailMessage) ? `${located}: ${detailMessage}` : located;
     const base = textResult(message, { error: metadata });
     return { ...base, isError: true };
 }
+function describeDetailMessage(details) {
+    if (!details || typeof details !== "object") {
+        return undefined;
+    }
+    const message = details.message;
+    return typeof message === "string" && message.trim().length > 0 ? message.trim() : undefined;
+}
 export function unknownErrorResult(error) {
     if (error instanceof ToolError) {
         return toolErrorResult(error);

package/dist/tools/hex.js

@@ -0,0 +1,9 @@
+/**
+ * Normalise a user-supplied hex byte string such as "$A9 $00", "A9_00" or
+ * "$A900" to bare hex digits. A "$" may prefix the whole string or each
+ * whitespace-separated byte group; whitespace and "_" separators are removed.
+ * The result is not validated, so callers still check length and digits.
+ */
+export function stripHexByteSeparators(input) {
+    return input.trim().replace(/(^|\s)\$/g, "$1").replace(/[\s_]/g, "");
+}

package/dist/tools/input.js

@@ -68,25 +68,31 @@ const PETSCII_TOKENS = {
     CURSOR_LEFT: 157,
     CURSOR_RIGHT: 29,
 };
+// ASCII a-z are shifted graphics characters in PETSCII, so typed "print" would
+// reach BASIC as graphics and give ?SYNTAX ERROR. Literal letters are therefore
+// sent as the unshifted PETSCII letters $41-$5A; {tokens} keep their codes.
 function expandPetsciiTokens(text) {
-    return text.replace(/\{([^}]+)\}/g, (_match, token) => {
+    return text.replace(/\{([^}]+)\}|[a-z]/g, (_match, token) => {
+        if (token === undefined) {
+            return _match.toUpperCase();
+        }
         const upper = token.trim().toUpperCase();
         const code = PETSCII_TOKENS[upper];
         if (code !== undefined) {
             return String.fromCharCode(code);
         }
-        // Numeric form: {$1D} or {29}
-        let num;
-        if (upper.startsWith("$")) {
+        // Numeric form: {$1D} or {29}. Anchored, so {12AB} is not read as {12}.
+        let num = NaN;
+        if (/^\$[0-9A-F]{1,2}$/.test(upper)) {
             num = parseInt(upper.slice(1), 16);
         }
-        else {
+        else if (/^\d{1,3}$/.test(upper)) {
             num = parseInt(upper, 10);
         }
         if (!isNaN(num) && num >= 0 && num <= 255) {
             return String.fromCharCode(num);
         }
-        return _match; // leave unrecognised tokens as-is
+        return _match.toUpperCase(); // type unrecognised tokens literally
     });
 }
 // ---------------------------------------------------------------------------
@@ -266,7 +272,7 @@ const inputOperationHandlers = {
             const keyByte = tokenCode !== undefined
                 ? tokenCode
                 : parsed.key.length === 1
-                    ? parsed.key.charCodeAt(0) & 0xff
+                    ? parsed.key.toUpperCase().charCodeAt(0) & 0xff
                     : (() => {
                         throw new ToolValidationError(`Unrecognised key: ${parsed.key}. Use a single character or a PETSCII token name.`, { path: "$.key" });
                     })();

package/dist/tools/memory.js

@@ -8,6 +8,7 @@ import { ToolError, ToolExecutionError, ToolValidationError, toolErrorResult, un
 import { disassemble, formatDisassembly } from "./translation/disassembler.js";
 import { getViceSymbols } from "./translation/symbolRegistry.js";
 import { resolveAddressSymbol } from "../knowledge.js";
+import { stripHexByteSeparators } from "./hex.js";
 function toRecord(details) {
     if (details && typeof details === "object") {
         return details;
@@ -24,9 +25,7 @@ function normaliseFailure(details) {
     return { value: details };
 }
 function cleanHex(input) {
-    const trimmed = input.trim();
-    const withoutPrefix = trimmed.startsWith("$") ? trimmed.slice(1) : trimmed;
-    return withoutPrefix.replace(/[\s_]/g, "").toUpperCase();
+    return stripHexByteSeparators(input).toUpperCase();
 }
 function parseHexInternal(value, path) {
     const cleaned = cleanHex(value);
@@ -201,7 +200,9 @@ async function executeReadMemory(rawArgs, ctx) {
             hexData: result.data ?? null,
             details: detailRecord,
         };
-        const base = textResult(`Read ${resolvedLength} bytes starting at ${resolvedAddress}.`, data);
+        // Many clients show only the text content, so it carries the bytes too.
+        const hexSummary = typeof result.data === "string" && result.data.length > 0 ? `\n${result.data}` : "";
+        const base = textResult(`Read ${resolvedLength} bytes starting at ${resolvedAddress}.${hexSummary}`, data);
         return {
             ...base,
             structuredContent: {

package/dist/tools/meta/background.js

@@ -231,7 +231,12 @@ const noArgsSchema = objectSchema({ description: "No arguments", properties: {},
 const startBackgroundTaskArgsSchema = objectSchema({
     description: "Start a named background task that invokes a simple operation at fixed intervals.",
     properties: {
-        name: stringSchema({ description: "Unique task name", minLength: 1 }),
+        // The name becomes part of the task folder path, so it must be a single safe path segment.
+        name: stringSchema({
+            description: "Unique task name (letters, digits, spaces, '_', '-', '.'; must not start with '.' or a space).",
+            minLength: 1,
+            pattern: /^[A-Za-z0-9_][A-Za-z0-9_. -]*$/,
+        }),
         operation: stringSchema({ description: "Operation name (e.g., read, read_screen)", minLength: 1 }),
         arguments: optionalSchema(objectSchema({ description: "Operation-specific arguments", properties: {}, additionalProperties: true }), {}),
         intervalMs: optionalSchema(numberSchema({ description: "Interval milliseconds", integer: true, minimum: 1, default: 1000 }), 1000),

package/dist/tools/meta/filesystem.js

@@ -45,6 +45,28 @@ const filesystemStatsArgsSchema = objectSchema({
     required: [],
     additionalProperties: false,
 });
+/**
+ * Find a drive in drivesList() output. Ultimate firmware lists drives as a/b
+ * with a configurable bus_id, so "drive8" or "8" is matched by bus number.
+ */
+function findListedDrive(drives, drive) {
+    const wanted = drive.trim().toLowerCase();
+    const exact = drives.find((d) => String(d?.id ?? "").toLowerCase() === wanted);
+    if (exact)
+        return exact;
+    // VICE lists drives as driveN; the Ultimate letters a and b default to buses 8 and 9 there.
+    const letterBus = wanted === "a" ? 8 : wanted === "b" ? 9 : undefined;
+    const bus = /^(?:drive)?\s*(\d+)$/.exec(wanted);
+    if (!bus && letterBus === undefined)
+        return undefined;
+    const busId = letterBus ?? Number(bus[1]);
+    if (letterBus !== undefined) {
+        return drives.find((d) => String(d?.id ?? "").toLowerCase() === `drive${busId}`);
+    }
+    const onBus = drives.filter((d) => Number(d?.raw?.bus_id) === busId || String(d?.id ?? "").toLowerCase() === `drive${busId}`);
+    // Prefer the enabled drive; a disabled drive can keep the same bus_id setting.
+    return onBus.find((d) => d?.raw?.enabled !== false) ?? onBus[0];
+}
 function extractPaths(value) {
     const acc = [];
     const stack = [value];
@@ -651,7 +673,7 @@ export const tools = [
                 if (powerOnIfNeeded) {
                     try {
                         const drives = await ctx.client.drivesList();
-                        const targetDrive = Array.isArray(drives) ? drives.find((d) => d.id === drive) : null;
+                        const targetDrive = Array.isArray(drives) ? findListedDrive(drives, drive) : null;
                         if (!targetDrive) {
                             log.push({ step: "check_drive_exists", success: false, error: `Drive ${drive} not found` });
                             throw new ToolExecutionError(`Drive ${drive} not found in firmware drive list`, { details: { drive } });
@@ -676,18 +698,23 @@ export const tools = [
                         throw new ToolExecutionError("Failed to check or power on drive", { details: { error: error instanceof Error ? error.message : String(error) } });
                     }
                 }
-                // Step 2: Mount with retries
+                // Step 2: Switch the drive emulation mode. The mount's own "mode"
+                // option is the read/write attachment mode, not the drive type.
+                if (mode) {
+                    const setMode = await ctx.client.driveSetMode(drive, mode);
+                    log.push({ step: "set_mode", success: setMode.success === true, details: setMode.details });
+                    if (!setMode.success) {
+                        throw new ToolExecutionError(`Failed to set drive ${drive} to ${mode} mode`, { details: setMode.details });
+                    }
+                }
+                // Step 3: Mount with retries
                 let mountSuccess = false;
                 let lastMountError = null;
                 let attempts = 0;
                 for (let attempt = 0; attempt <= maxRetries && !mountSuccess; attempt += 1) {
                     attempts = attempt + 1;
                     try {
-                        const mountOptions = {};
-                        if (mode) {
-                            mountOptions.mode = mode;
-                        }
-                        const mount = await ctx.client.driveMount(drive, imagePath, mountOptions);
+                        const mount = await ctx.client.driveMount(drive, imagePath);
                         if (mount.success) {
                             mountSuccess = true;
                             log.push({ step: `mount_attempt_${attempts}`, success: true, details: mount.details });
@@ -717,7 +744,7 @@ export const tools = [
                         details: { lastError: lastMountError }
                     });
                 }
-                // Step 3: Reset drive if requested
+                // Step 4: Reset drive if requested
                 if (resetAfterMount) {
                     try {
                         const reset = await ctx.client.driveReset(drive);
@@ -735,12 +762,12 @@ export const tools = [
                         ctx.logger.warn?.("Drive reset threw error", { error });
                     }
                 }
-                // Step 4: Verify mount
+                // Step 5: Verify mount
                 let verificationResult = null;
                 if (verifyMount) {
                     try {
                         const drives = await ctx.client.drivesList();
-                        const targetDrive = Array.isArray(drives) ? drives.find((d) => d.id === drive) : null;
+                        const targetDrive = Array.isArray(drives) ? findListedDrive(drives, drive) : null;
                         if (!targetDrive) {
                             log.push({ step: "verify", success: false, error: "Drive not found in list" });
                             throw new ToolExecutionError("Drive disappeared after mount", { details: { drive } });

package/dist/tools/meta/graphics.js

@@ -13,21 +13,16 @@ function parseAddressNumeric(value) {
         throw new ToolValidationError("Address must be a non-empty string", { path: "$.address" });
     }
     const trimmed = value.trim();
-    let literal = trimmed;
-    let radix = 10;
-    if (trimmed.startsWith("$")) {
-        radix = 16;
-        literal = trimmed.slice(1);
-    }
-    else if (trimmed.startsWith("0x")) {
-        radix = 16;
-        literal = trimmed.slice(2);
-    }
-    else if (trimmed.startsWith("%")) {
-        radix = 2;
-        literal = trimmed.slice(1);
-    }
-    const parsed = Number.parseInt(literal, radix);
+    // Anchored patterns: Number.parseInt alone would read "$08G0" as $0008.
+    let parsed = Number.NaN;
+    if (/^\$[0-9a-f]+$/i.test(trimmed))
+        parsed = Number.parseInt(trimmed.slice(1), 16);
+    else if (/^0x[0-9a-f]+$/i.test(trimmed))
+        parsed = Number.parseInt(trimmed.slice(2), 16);
+    else if (/^%[01]+$/.test(trimmed))
+        parsed = Number.parseInt(trimmed.slice(1), 2);
+    else if (/^[0-9]+$/.test(trimmed))
+        parsed = Number.parseInt(trimmed, 10);
     if (!Number.isFinite(parsed) || Number.isNaN(parsed)) {
         throw new ToolValidationError("Invalid address value", { path: "$.address", details: { value } });
     }

package/dist/tools/meta/memory.js

@@ -5,14 +5,13 @@ import { promises as fs } from "node:fs";
 import { dirname, resolve as resolvePath } from "node:path";
 import { createHash } from "node:crypto";
 import { normalizeErrorDetails } from "./util.js";
+import { stripHexByteSeparators } from "../hex.js";
 function supportsMachinePause(ctx) {
     const platformId = ctx.platform?.id ?? ctx.client?.type;
     return platformId !== "vice";
 }
 function hexClean(input) {
-    const trimmed = input.trim();
-    const withoutPrefix = trimmed.startsWith("$") ? trimmed.slice(1) : trimmed;
-    return withoutPrefix.replace(/[\s_]/g, "").toLowerCase();
+    return stripHexByteSeparators(input).toLowerCase();
 }
 function hexToBytes(input) {
     const cleaned = hexClean(input);
@@ -31,21 +30,16 @@ function parseAddressNumeric(value) {
         throw new ToolValidationError("Address must be a non-empty string", { path: "$.address" });
     }
     const lower = value.trim().toLowerCase();
-    let radix = 10;
-    let literal = lower;
-    if (lower.startsWith("$")) {
-        radix = 16;
-        literal = lower.slice(1);
-    }
-    else if (lower.startsWith("0x")) {
-        radix = 16;
-        literal = lower.slice(2);
-    }
-    else if (lower.startsWith("%")) {
-        radix = 2;
-        literal = lower.slice(1);
-    }
-    const parsed = Number.parseInt(literal, radix);
+    // Anchored patterns: Number.parseInt alone would read "$20ZZ" as $0020.
+    let parsed = Number.NaN;
+    if (/^\$[0-9a-f]+$/.test(lower))
+        parsed = Number.parseInt(lower.slice(1), 16);
+    else if (/^0x[0-9a-f]+$/.test(lower))
+        parsed = Number.parseInt(lower.slice(2), 16);
+    else if (/^%[01]+$/.test(lower))
+        parsed = Number.parseInt(lower.slice(1), 2);
+    else if (/^[0-9]+$/.test(lower))
+        parsed = Number.parseInt(lower, 10);
     if (!Number.isFinite(parsed) || Number.isNaN(parsed) || parsed < 0 || parsed > 0xFFFF) {
         throw new ToolValidationError("Invalid address value", { path: "$.address", details: { value } });
     }

package/dist/tools/meta/program.js

@@ -8,6 +8,7 @@ import { sleep, formatTimestampSpec } from "./util.js";
 import { getTasksHomeDir } from "./background.js";
 import { Jimp } from "jimp";
 import { withDiagnosticSpan } from "../../diagnostics.js";
+import { stripHexByteSeparators } from "../hex.js";
 const C64_SCREENSHOT_PALETTE = [
     0x000000ff,
     0xffffffff,
@@ -62,6 +63,9 @@ function canonicalGreetingBackends() {
 function uniqueGreetingBackends(backends) {
     return backends.filter((backend, index) => backends.indexOf(backend) === index);
 }
+function normaliseAssertionHex(value) {
+    return stripHexByteSeparators(value).toUpperCase();
+}
 function normaliseScreenText(screen) {
     return screen.replace(/\r\n?/g, "\n").replace(/\s+/g, " ").trim().toUpperCase();
 }
@@ -696,9 +700,17 @@ export const tools = [
                             else if (assertion.type === "memory_equals") {
                                 const addr = assertion.address ?? "$0400";
                                 const expected = assertion.expected ?? "$00";
-                                const result = await ctx.client.readMemory(addr, "1");
-                                const actual = result.data ?? "$00";
-                                const matched = actual.toLowerCase() === expected.toLowerCase();
+                                // Compare every expected byte, and treat a failed read as an error rather than as $00.
+                                const expectedHex = normaliseAssertionHex(expected);
+                                if (expectedHex.length === 0 || expectedHex.length % 2 !== 0 || !/^[0-9A-F]+$/.test(expectedHex)) {
+                                    throw new Error(`memory_equals expected value ${expected} is not a whole number of hex bytes`);
+                                }
+                                const result = await ctx.client.readMemory(addr, String(expectedHex.length / 2));
+                                if (!result.success || typeof result.data !== "string") {
+                                    throw new Error(`Failed to read memory at ${addr} for memory_equals assertion`);
+                                }
+                                const actual = result.data;
+                                const matched = normaliseAssertionHex(actual) === expectedHex;
                                 assertionResults.push({
                                     type: assertion.type,
                                     status: matched ? "pass" : "fail",
@@ -710,7 +722,10 @@ export const tools = [
                             else if (assertion.type === "sid_silent") {
                                 // Check SID gate bits are off (simple check)
                                 const result = await ctx.client.readMemory("$D404", "1");
-                                const gate1 = parseInt((result.data ?? "$00").slice(1), 16) & 0x01;
+                                if (!result.success || typeof result.data !== "string") {
+                                    throw new Error("Failed to read SID voice 1 control register for sid_silent assertion");
+                                }
+                                const gate1 = parseInt(result.data.slice(1), 16) & 0x01;
                                 const isSilent = gate1 === 0;
                                 assertionResults.push({
                                     type: assertion.type,

package/dist/tools/pollValidator.js

@@ -75,7 +75,7 @@ function concatBuffers(...buffers) {
  * Looks for patterns like "?SYNTAX ERROR" or "SYNTAX ERROR IN 120".
  */
 function extractBasicError(screen) {
-    const errorMatch = /(?:^|\n)\s*\?([A-Z\s]+?)\s+ERROR(?:\s+IN\s+(\d+))?(?=\s|$)/im.exec(screen); // A real error has a leading "?"; ordinary output like "0 ERRORS FOUND" must never match.
+    const errorMatch = /(?:^|\n)\s*\?([A-Z'\s]+?)\s+ERROR(?:\s+IN\s+(\d+))?(?=\s|$)/im.exec(screen); // A real error has a leading "?"; ordinary output like "0 ERRORS FOUND" must never match. The apostrophe covers UNDEF'D STATEMENT, REDIM'D ARRAY and CAN'T CONTINUE.
     if (errorMatch) {
         const errorType = errorMatch[1]?.trim().replace(/\s+/g, " ");
         const lineStr = errorMatch[2];
@@ -87,6 +87,19 @@ function extractBasicError(screen) {
     }
     return null;
 }
+/**
+ * True when the most recent typed SYS command is followed by a READY. prompt,
+ * which is how a machine-code routine that ends with RTS hands back to BASIC.
+ */
+function returnedToBasicAfterSys(screen) {
+    const lines = screen.split("\n").map((line) => line.trim().toUpperCase());
+    let sysLine = -1;
+    lines.forEach((line, index) => {
+        if (/^SYS\s*\d+$/.test(line))
+            sysLine = index;
+    });
+    return sysLine >= 0 && lines.slice(sysLine + 1).some((line) => line === "READY.");
+}
 /**
  * Poll for BASIC program outcome by detecting errors on screen.
  * First waits for RUN or ERROR to appear, then continues polling for errors.
@@ -157,7 +170,12 @@ async function pollAsmOutcome(client, logger, config) {
         try {
             const screen = await client.readScreen();
             const upperScreen = screen.toUpperCase();
-            if (upperScreen.includes("RUN") || upperScreen.includes("ERROR")) {
+            if (returnedToBasicAfterSys(screen)) {
+                // The typed SYS line is followed by READY., so the routine ran and returned with RTS.
+                logger.debug("ASM program returned to BASIC", { elapsed: Date.now() - startTime });
+                return { status: "ok", type: "ASM" };
+            }
+            if (upperScreen.includes("RUN") || upperScreen.includes("SYS") || upperScreen.includes("ERROR")) {
                 runDetected = true;
                 logger.debug("RUN detected, starting stabilization window", {
                     elapsed: Date.now() - startTime,
@@ -182,6 +200,16 @@ async function pollAsmOutcome(client, logger, config) {
     const pollDeadline = Date.now() + config.maxMs;
     while (Date.now() < pollDeadline && !alive) {
         pollCount++;
+        try {
+            // A routine that works for a while before RTS shows READY. only after the first screen read.
+            if (returnedToBasicAfterSys(await client.readScreen())) {
+                logger.debug("ASM program returned to BASIC", { pollCount, elapsed: Date.now() - startTime });
+                return { status: "ok", type: "ASM" };
+            }
+        }
+        catch (error) {
+            logger.debug("Failed to read screen during ASM polling", { error, pollCount });
+        }
         try {
             const screenRam = await client.readMemoryRaw(0x0400, 0x03e8);
             const signature = computeCrc32(screenRam);

package/dist/tools/programRunners.js

@@ -1,5 +1,5 @@
 import fs from "node:fs";
-import { assemblyToPrgDetailed, AssemblyError } from "./translation/assembler.js";
+import { assemblyToPrgDetailed, AssemblyError, prgEntryAddress } from "./translation/assembler.js";
 import { basicToPrg } from "./translation/basicTokenizer.js";
 import { defineToolModule, OPERATION_DISCRIMINATOR, } from "./types.js";
 import { booleanSchema, objectSchema, optionalSchema, stringSchema } from "./schema.js";
@@ -52,7 +52,8 @@ function parseBasicRuntimeErrors(screen) {
             continue;
         }
         seen.add(lineNumber);
-        const typeMatch = /\?([A-Z ?]+?)\s+ERROR\s+IN/i.exec(row.toUpperCase());
+        // The apostrophe covers UNDEF'D STATEMENT, REDIM'D ARRAY and UNDEF'D FUNCTION.
+        const typeMatch = /\?([A-Z' ?]+?)\s+ERROR\s+IN/i.exec(row.toUpperCase());
         const type = typeMatch?.[1]?.trim().replace(/\s+/g, " ") || undefined;
         errors.push({
             line: lineNumber,
@@ -441,7 +442,7 @@ async function executeUploadRunAsm(rawArgs, ctx) {
         // Assemble locally to expose structured metadata and capture symbols
         const asmResult = assemblyToPrgDetailed(parsed.program);
         const prg = asmResult.prg;
-        const entryAddress = prg.readUInt16LE(0);
+        const entryAddress = prgEntryAddress(prg);
         if (ctx.platform.id === "vice") {
             setViceSymbols(asmResult.symbols.entries());
         }
@@ -686,7 +687,7 @@ export const programRunnersModule = defineToolModule({
                 {
                     name: "Set screen char",
                     description: "Write 1 to $0400 then RTS",
-                    arguments: { program: ".org $0801\nstart: lda #$01\n sta $0400\n rts" },
+                    arguments: { program: "start: lda #$01\n sta $0400\n rts" },
                 },
             ],
             workflowHints: [