feat(rd-18): Slice 8b Phase 5 — acceptance tier GREEN (3-part bar on real VICE)

- examples/slice8b fixture + committed 8-byte table.bin: PETSCII string
  const, embed() through the real source-relative reader, bracketed string
  init with char fill + char-store mutation, char-literal comparison; copy
  through by-ref const src + by-ref mutable dst staging arrays
- Fixture corrections vs the plan listing (mechanical, oracles unchanged):
  <word>(i) cast form; hoisted inclusive-to bound; poke's compile-time-
  constant-address rule (E10045) → staging copy + const-address pokes
- Fixes a REAL shipped codegen bug the fixture exposed: _cmpN/_shN
  generated labels restarted per function (global assembler symbols →
  "Symbol already defined" as soon as two functions compare); program-
  shared label allocator through generateInstr; eleven prior goldens stay
  byte-exact
- Harness slice8b module (absolute outDir, asset staging), negatives suite
  8/8 (E10200/01/02/05, E10116, E10124, E10127, format E90001), 205-line
  golden + landmarks, VICE runtime GREEN FIRST RUN ($0400 title, $C000
  table, $C010 banner, $C020 flag)
- Verification: passing (full chain, 17/17; harness 173 tests)

Ref: codeops/features/blend65-ri/plans/rd-18-slice-8b-strings-embed/99-execution-plan.md
Tasks: 5.1.1-5.2.4

Author: gevik

codeops/features/blend65-ri/plans/rd-18-slice-8b-strings-embed/00-ambiguity-register.md

@@ -71,6 +71,22 @@ re-check (AR-10 mechanics, RD-18 "canonicalize" clause); the raw no-profile enco
 `SemanticModel`/`ConstValue` provenance edits are `@blend65/core` changes; citation fixes
 (Ch 15 §6; EMB-1 vs the AR-11 tightening; ST-25..35/ST-40 ids).
 
+**Runtime corrections (2026-07-17, exec_plan Phase 5 — mechanical, no decided outcome changed):**
+the 03-04 fixture listing was not legal blend65 on three counts, corrected during execution with
+the oracles (observables table, golden landmarks, proof points) preserved byte-for-byte:
+(1) `word(i)` → `<word>(i)` (the language's cast form; `word(i)` parses as an undeclared call);
+(2) `for (… = 0 to len)` → a hoisted `last = len - 1` bound (`to` is INCLUSIVE — slice7's
+`0 to 4` covers five elements — and the for-bound parses as a primary expression);
+(3) `poke(dst + <word>(i), …)` violates poke's compile-time-constant-address rule (E10045) —
+the copy became by-ref-array staging (`copyBytes(src: const byte[], dst: byte[], len)`) with
+unrolled const-address pokes relaying the staged bytes to the observable ranges, which also
+exercises the mutable by-ref array parameter path. Additionally the fixture exposed a REAL
+shipped codegen bug: `_cmpN`/`_shN` generated labels are global assembler symbols but their
+counter reset per function, so any program with two comparison-bearing functions failed ACME
+("Symbol already defined") — fixed with a program-shared label allocator threaded through
+`generateInstr` (`translate.ts`/`instr-program.ts`); all eleven prior goldens stay byte-exact
+(any prior hitting the bug could never have assembled).
+
 **Deferral consequences (stated at deferral):** AR-4 leaves the four encoding intrinsics +
 `encode()` unparsed-as-intrinsics (they fail as undeclared identifiers); AR-11 leaves format-aware
 embed behind a loud E90001; AR-5 defers full encoding-table fidelity (graphics chars, shifted

codeops/features/blend65-ri/plans/rd-18-slice-8b-strings-embed/03-04-acceptance.md

@@ -6,6 +6,13 @@
 
 ## The fixture — `examples/slice8b/main.blend` (+ `table.bin`)
 
+> **Runtime corrections (mechanical, 2026-07-17, exec_plan):** the original listing used
+> `word(i)` (the language's cast form is `<word>(expr)` — `word(i)` parses as a call to an
+> undeclared identifier) and `for (… = 0 to len)` (`to` is INCLUSIVE — slice7's `0 to 4`
+> covers five elements — so `to len` would copy len+1 bytes); the for-bound is a PRIMARY
+> expression, so the fix hoists `len - 1` into a local. Observables unchanged. The fixture
+> comments also drop their register citations per the documentation ban.
+
 ```blend65
 module Main;
 
@@ -14,8 +21,9 @@ const TABLE: byte[] = embed("table.bin");  // 8 committed bytes: $01 02 04 08 10
 let banner: byte[8] = ["HI"; '.'];         // bracketed string + char fill (AR-8 form 2)
 
 function copyBytes(src: const byte[], len: byte, dst: word): void {
-  for (let i: byte = 0 to len) {
-    poke(dst + word(i), src[i]);
+  let last: byte = len - 1;
+  for (let i: byte = 0 to last) {
+    poke(dst + <word>(i), src[i]);
   }
 }
 

codeops/features/blend65-ri/plans/rd-18-slice-8b-strings-embed/99-execution-plan.md

@@ -2,8 +2,8 @@
 
 > **Document**: 99-execution-plan.md
 > **Parent**: [Index](00-index.md)
-> **Last Updated**: 2026-07-17 20:12
-> **Progress**: 43/58 tasks (74%)
+> **Last Updated**: 2026-07-17 21:10
+> **Progress**: 52/58 tasks (90%)
 > **CodeOps Skills Version**: 3.8.0
 
 ## Overview
@@ -172,18 +172,18 @@ implement → green → impl tests → full verify). Designs live in the 03-docs
 
 **Reference**: 03-04 · AR-14 · ST-36..40
 
-- [ ] 5.1.1 Create `examples/slice8b/main.blend` + committed `table.bin` (verbatim per 03-04); harness `slice8b.ts` (`SLICE8B_MAIN_SRC`, `buildSlice8b` with ABSOLUTE outDir, asset staging)
-- [ ] 5.1.2 Write `slice8b.spec.test.ts` (ST-36 assemble-clean + ST-37 VICE observables) — `packages/test-harness/src/`
-- [ ] 5.1.3 Write `slice8b-negatives.spec.test.ts` (ST-40, one per code) — `packages/test-harness/src/`
-- [ ] 5.1.4 Write `golden-slice8b.spec.test.ts` (ST-38 landmarks + ST-39 prior-goldens sweep) — `packages/test-harness/src/`
-- [ ] 5.1.5 Run assemble/negatives/golden suites — confirm expected red (no golden yet) and assemble-clean status
+- [x] 5.1.1 Create `examples/slice8b/main.blend` + committed `table.bin` (verbatim per 03-04); harness `slice8b.ts` (`SLICE8B_MAIN_SRC`, `buildSlice8b` with ABSOLUTE outDir, asset staging) ✅ (completed: 2026-07-17 20:52; impl 20:24 — **runtime corrections (mechanical)**: `word(i)` → `<word>(i)` (the cast form; `word(i)` parses as an undeclared call) and `0 to len` → hoisted `last = len - 1` bound (`to` is INCLUSIVE per slice7's 0-to-4-over-5-elements pin; the for-bound is a primary expression); corrections recorded in 03-04)
+- [x] 5.1.2 Write `slice8b.spec.test.ts` (ST-36 assemble-clean + ST-37 VICE observables) — `packages/test-harness/src/` ✅ (completed: 2026-07-17 20:52; impl 20:24)
+- [x] 5.1.3 Write `slice8b-negatives.spec.test.ts` (ST-40, one per code) — `packages/test-harness/src/` ✅ (completed: 2026-07-17 20:52; impl 20:24 — 8 codes incl. the existence-irrelevant E10205 probe)
+- [x] 5.1.4 Write `golden-slice8b.spec.test.ts` (ST-38 landmarks + ST-39 prior-goldens sweep) — `packages/test-harness/src/` ✅ (completed: 2026-07-17 20:52; impl 20:24 — ST-39's eleven-priors sweep = the existing per-slice golden suites running green in the same tier, noted in the doc comment)
+- [x] 5.1.5 Run assemble/negatives/golden suites — confirm expected red (no golden yet) and assemble-clean status ✅ (completed: 2026-07-17 20:52 — negatives 8/8 green immediately; assemble red exposed TWO real issues, both fixed under 5.2.1: the fixture's poke const-address violation (E10045; redesigned to by-ref staging + const-address pokes, oracles unchanged) and the shipped cross-function `_cmp`/`_sh` label collision (program-shared allocator; priors byte-exact))
 
 ### Step 5.2: Bar
 
-- [ ] 5.2.1 Fix any assemble/negative failures; mint `test/golden/slice8b.asm.golden` once ASM is correct-by-inspection against 03-04 landmarks
-- [ ] 5.2.2 Run the VICE runtime suite on real VICE 3.10 — ST-37 observables GREEN (local tier)
-- [ ] 5.2.3 Verify the eleven prior goldens byte-exact (ST-39) + CI-tier suites green
-- [ ] 5.2.4 Full verify
+- [x] 5.2.1 Fix any assemble/negative failures; mint `test/golden/slice8b.asm.golden` once ASM is correct-by-inspection against 03-04 landmarks ✅ (completed: 2026-07-17 20:52 — 205-line golden; landmarks verified (PETSCII title row, verbatim table row, JSR __init + JSR _main, program-unique _cmp labels))
+- [x] 5.2.2 Run the VICE runtime suite on real VICE 3.10 — ST-37 observables GREEN (local tier) ✅ (completed: 2026-07-17 20:52 — GREEN FIRST RUN: $0400-09 title, $C000-07 table, $C010-17 banner, $C020 flag)
+- [x] 5.2.3 Verify the eleven prior goldens byte-exact (ST-39) + CI-tier suites green ✅ (completed: 2026-07-17 20:52 — 11/11 priors byte-exact under the label-allocator fix; harness package 173/173)
+- [x] 5.2.4 Full verify ✅ (completed: 2026-07-17 21:10 — 17/17 turbo tasks from the repo root; harness 48 files/173 tests incl. the 8b three-part bar; boundary tier green)
 
 **Verify**: (same command)
 

examples/slice8b/main.blend

@@ -0,0 +1,53 @@
+module Main;
+
+const TITLE: byte[] = "HELLO C64!";        // 10 bytes, PETSCII-encoded
+const TABLE: byte[] = embed("table.bin");  // 8 committed bytes: $01 02 04 08 10 20 40 80
+let banner: byte[8] = ["HI"; '.'];         // bracketed string + char-literal fill
+let title2: byte[10];                      // staging: the copied screen text
+let table2: byte[8];                       // staging: the copied embed bytes
+
+function copyBytes(src: const byte[], dst: byte[], len: byte): void {
+  let last: byte = len - 1;
+  for (let i: byte = 0 to last) {
+    dst[i] = src[i];
+  }
+}
+
+function main(): void {
+  copyBytes(TITLE, title2, length(TITLE)); // by-ref const src, by-ref dst, length() fold
+  copyBytes(TABLE, table2, length(TABLE)); // embedded bytes through the same copy path
+  banner[0] = 'B';                         // mutable string mutation via a char literal
+
+  poke($0400, title2[0]);                  // screen RAM: the copied title
+  poke($0401, title2[1]);
+  poke($0402, title2[2]);
+  poke($0403, title2[3]);
+  poke($0404, title2[4]);
+  poke($0405, title2[5]);
+  poke($0406, title2[6]);
+  poke($0407, title2[7]);
+  poke($0408, title2[8]);
+  poke($0409, title2[9]);
+
+  poke($C000, table2[0]);                  // the copied embed bytes
+  poke($C001, table2[1]);
+  poke($C002, table2[2]);
+  poke($C003, table2[3]);
+  poke($C004, table2[4]);
+  poke($C005, table2[5]);
+  poke($C006, table2[6]);
+  poke($C007, table2[7]);
+
+  poke($C010, banner[0]);                  // the mutated banner
+  poke($C011, banner[1]);
+  poke($C012, banner[2]);
+  poke($C013, banner[3]);
+  poke($C014, banner[4]);
+  poke($C015, banner[5]);
+  poke($C016, banner[6]);
+  poke($C017, banner[7]);
+
+  if (TITLE[0] == 'H') {                   // char-literal comparison against encoded data
+    poke($C020, 1);
+  }
+}

examples/slice8b/table.bin

@@ -0,0 +1 @@
+
 @�

packages/codegen/src/instr/instr-program.ts

@@ -77,6 +77,10 @@ export function generateInstr(
 ): InstrProgram {
   const plan = ilProgram.allocationPlan;
   const streams: InstrStream[] = [];
+  // One comparison-label sequence for the whole program — the `_cmpN`
+  // labels are global assembler symbols, so per-function restarts would
+  // collide as soon as two functions both compare.
+  const sharedOpts: TranslateOptions = { ...opts, cmpLabels: { next: 0 } };
 
   if (ilProgram.initCode.length > 0) {
     // The module-initializer stream, shaped like a void function so the
@@ -90,7 +94,7 @@ export function generateInstr(
       tempCount: ilProgram.initTempCount,
       isInterrupt: false,
     };
-    const initStream = translateFunction(initFn, plan, cpuVariant, bag, opts);
+    const initStream = translateFunction(initFn, plan, cpuVariant, bag, sharedOpts);
     validateStream(initStream, cpuVariant, bag);
     streams.push(initStream);
   }
@@ -101,7 +105,7 @@ export function generateInstr(
     if (!hasBody) {
       continue;
     }
-    const stream = translateFunction(fn, plan, cpuVariant, bag, opts);
+    const stream = translateFunction(fn, plan, cpuVariant, bag, sharedOpts);
     // Post-translation validation: every emitted opcode+mode must be CPU-legal
     // for the variant; an illegal pair is an E90001 codegen bug.
     validateStream(stream, cpuVariant, bag);

packages/codegen/src/instr/translate.ts

@@ -70,6 +70,14 @@ export interface TranslateOptions {
   readonly zpArgBlockSize?: number;
   /** The target platform id, for the E10044 message. */
   readonly platformId?: string;
+  /**
+   * A program-shared comparison-label allocator. The `_cmpN` labels are
+   * global assembler symbols, so every function of one program must draw
+   * from a single sequence — two functions both starting at `_cmp0` would
+   * collide at assembly. Absent (single-function translation in tests),
+   * a translator-local counter serves.
+   */
+  readonly cmpLabels?: { next: number };
 }
 
 /**
@@ -177,9 +185,23 @@ class FunctionTranslator {
   private leadSpan: SourceSpan | undefined = undefined;
   /** Instruction index whose `store` has been folded into a word ALU (skip it). */
   private skipIndex = -1;
-  /** Per-function generated-label counter (`_cmpN`). Reserved for comparisons. */
+  /**
+   * Fallback generated-label counter (`_cmpN`) for translator-local use
+   * when no program-shared allocator is supplied.
+   */
   private cmpCounter = 0;
 
+  /** The next program-unique generated-label number (shared across families). */
+  private nextLabelNumber(): number {
+    const shared = this.opts?.cmpLabels;
+    return shared !== undefined ? shared.next++ : this.cmpCounter++;
+  }
+
+  /** The next program-unique comparison label. */
+  private nextCmpLabel(): string {
+    return `_cmp${this.nextLabelNumber()}`;
+  }
+
   constructor(
     private readonly fn: ILFunction,
     private readonly plan: AllocationPlan,
@@ -713,8 +735,8 @@ class FunctionTranslator {
       }
       const count = this.rightSource(right, 0);
       this.emit("LDX", count.mode, count.operand);
-      const loopL = `_sh${this.cmpCounter++}`;
-      const doneL = `_sh${this.cmpCounter++}`;
+      const loopL = `_sh${this.nextLabelNumber()}`;
+      const doneL = `_sh${this.nextLabelNumber()}`;
       this.emit("BEQ", "Relative", labelRef(doneL)); // a zero count shifts nothing
       this.out.push(label(loopL));
       this.emitByteShiftStep(op, signedShr);
@@ -741,8 +763,8 @@ class FunctionTranslator {
     }
     const count = this.rightSource(right, 0);
     this.emit("LDX", count.mode, count.operand);
-    const loopL = `_sh${this.cmpCounter++}`;
-    const doneL = `_sh${this.cmpCounter++}`;
+    const loopL = `_sh${this.nextLabelNumber()}`;
+    const doneL = `_sh${this.nextLabelNumber()}`;
     this.emit("BEQ", "Relative", labelRef(doneL));
     this.out.push(label(loopL));
     this.emitWordShiftStep(op, signedShr, home);
@@ -1042,7 +1064,7 @@ class FunctionTranslator {
     } else {
       // Carry-based (BCC/BCS): `LDA` preserves the carry flag, so the compact
       // form is correct — the branch tests the carry `CMP` set.
-      const done = `_cmp${this.cmpCounter++}`;
+      const done = this.nextCmpLabel();
       this.emit("LDA", "Immediate", imm8(0x01));
       this.emit(branch, "Relative", labelRef(done));
       this.emit("LDA", "Immediate", imm8(0x00));
@@ -1053,8 +1075,8 @@ class FunctionTranslator {
 
   /** Branch-taken ⇒ 1: materialise the 0/1 from a flag-fresh branch opcode. */
   private materialiseOnBranch(branch: Opcode): void {
-    const trueL = `_cmp${this.cmpCounter++}`;
-    const endL = `_cmp${this.cmpCounter++}`;
+    const trueL = this.nextCmpLabel();
+    const endL = this.nextCmpLabel();
     this.emit(branch, "Relative", labelRef(trueL));
     this.emit("LDA", "Immediate", imm8(0x00));
     this.emit("JMP", "Absolute", labelRef(endL));
@@ -1079,7 +1101,7 @@ class FunctionTranslator {
     this.emit("SEC", "Implied", none());
     const r = this.rightSource(rhs, 0);
     this.emit("SBC", r.mode, r.operand);
-    const skipL = `_cmp${this.cmpCounter++}`;
+    const skipL = this.nextCmpLabel();
     this.emit("BVC", "Relative", labelRef(skipL));
     this.emit("EOR", "Immediate", imm8(0x80));
     this.out.push(label(skipL));
@@ -1089,7 +1111,7 @@ class FunctionTranslator {
 
   /** 16-bit equality: low bytes decide fast, high bytes break the tie (Z-based). */
   private wordEquality(op: "eq" | "ne", dest: ILOperand, lhs: ILOperand, rhs: ILOperand): void {
-    const diffL = `_cmp${this.cmpCounter++}`;
+    const diffL = this.nextCmpLabel();
     this.wordLeftByteIntoA(lhs, 0);
     const rLo = this.rightSource(rhs, 0);
     this.emit("CMP", rLo.mode, rLo.operand);
@@ -1115,9 +1137,9 @@ class FunctionTranslator {
     rhs: ILOperand,
   ): void {
     const wantLess = op === "lt" || op === "gt"; // after the caller's swap
-    const falseL = `_cmp${this.cmpCounter++}`;
-    const trueL = `_cmp${this.cmpCounter++}`;
-    const endL = `_cmp${this.cmpCounter++}`;
+    const falseL = this.nextCmpLabel();
+    const trueL = this.nextCmpLabel();
+    const endL = this.nextCmpLabel();
 
     this.wordLeftByteIntoA(lhs, 1);
     const rHi = this.rightSource(rhs, 1);
@@ -1161,7 +1183,7 @@ class FunctionTranslator {
     this.wordLeftByteIntoA(lhs, 1);
     const rHi = this.rightSource(rhs, 1);
     this.emit("SBC", rHi.mode, rHi.operand);
-    const skipL = `_cmp${this.cmpCounter++}`;
+    const skipL = this.nextCmpLabel();
     this.emit("BVC", "Relative", labelRef(skipL));
     this.emit("EOR", "Immediate", imm8(0x80));
     this.out.push(label(skipL));

packages/test-harness/src/golden-slice8b.spec.test.ts

@@ -0,0 +1,59 @@
+/**
+ * CI golden test for the Slice 8b fixture: emits the fixture's ACME source
+ * via `emitAsm` and `assertGolden`s it against the committed
+ * `test/golden/slice8b.asm.golden`, proving the data surface's emission
+ * stays byte-exact — the string const bakes its PETSCII bytes and the
+ * embedded file bakes its bytes verbatim under their data labels, the
+ * banner initialises through the init stream, and the terminating shim
+ * enters `main` with `JSR`. Runs in CI (no emulator, no ACME — `emitAsm`
+ * stops before the assembler).
+ *
+ * The ten prior slice goldens plus the gate golden stay byte-exact through
+ * their own suites in the same run — nothing here may change them.
+ *
+ * Regenerate after an intentional codegen change (inspect the diff first):
+ *   UPDATE_GOLDEN=1 yarn workspace @blend65/test-harness test golden-slice8b
+ */
+
+import { describe, expect, it } from "vitest";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { assertGolden } from "./golden.js";
+import { emitAsmSlice8b } from "./testing/slice8b.js";
+
+const GOLDEN = join(
+  dirname(fileURLToPath(import.meta.url)),
+  "..",
+  "test",
+  "golden",
+  "slice8b.asm.golden",
+);
+
+describe("Golden: Slice 8b fixture .asm snapshot", () => {
+  it("emits the Slice 8b ACME source and matches the committed golden", () => {
+    const result = emitAsmSlice8b();
+    expect(result.hasErrors).toBe(false);
+    expect(result.text).toBeDefined();
+    assertGolden(result.text!, GOLDEN);
+  });
+
+  it("carries the data-surface landmarks in the emitted source", () => {
+    const text = emitAsmSlice8b().text!;
+
+    // The string const bakes its PETSCII bytes under its data label.
+    expect(text).toContain("__data_Main_TITLE:");
+    expect(text).toContain("!byte $48, $45, $4C, $4C, $4F, $20, $43, $36, $34, $21");
+
+    // The embedded file bakes its bytes verbatim under its data label.
+    expect(text).toContain("__data_Main_TABLE:");
+    expect(text).toContain("!byte $01, $02, $04, $08, $10, $20, $40, $80");
+
+    // The banner is a mutable module variable initialised through the init
+    // stream (expanded string + char fill), not baked const data.
+    expect(text).toContain("__var_Main_banner");
+    expect(text).toContain("JSR __init");
+
+    // The fixture's main terminates — the terminating shim calls it.
+    expect(text).toContain("JSR _main");
+  });
+});