[jlongster]

Rollout Consequence

With the legacy AST interpreter removed, every build — including production releases (latest, beta) — now runs Code Mode on the bytecode VM unconditionally. Previously, codemode_vm defaulted to on only in local and dev builds and off in releases.

What Was Removed (10,578 deletions, 550 insertions across 77 files)

• Legacy interpreter & stdlib (packages/codemode):
  • src/interpreter/* (17 files, 5,767 lines)
  • src/stdlib/* (16 files, 3,486 lines)
  • src/data.ts (119 lines)
  • CodeMode.Engine type, Options.engine option, and lazy dynamic import("./vm/index.js") loading
  • test/engines.test.ts, test/fixtures/engine-modules.ts, test/lib/codemode.ts, CODEMODE_ENGINE env switching, and the legacy test/test262/run.ts harness (folded run-vm.ts into run.ts)
  • test:legacy and test:vm scripts in packages/codemode/package.json (test now runs the suite once on the VM; test:roundtrip remains)
• Feature flag & Core engine switching (packages/schema, packages/core, packages/server):
  • codemode_vm from ConfigFlag.registry (packages/schema/src/config/flag.ts)
  • codemodeVm normalization in packages/core/src/config/normalize.ts
  • Flag.Interface parameter, flag.enabled("codemode_vm") checks, and dual per-engine WeakMap runtime caches in packages/core/src/codemode/tool.ts
  • Flag.Service / Flag.node dependency from Tool.node in packages/core/src/tool.ts (Flag.Service remains in place for other flags)
  • codemode_vm channel assertions in packages/server/test/flag-channel.test.ts (retaining the media_blob channel checks)

API Cleanup

• CodeMode.Runtime: Merged VmRuntime into Runtime so program and resume live on Runtime directly, and removed the CodeMode.make overloads.
• Snapshot & suspend errors: Folded src/suspend-error.ts into its natural owners (SnapshotError in src/vm/snapshot/codec.ts, toBytes/fromBytes in src/vm/snapshot/snapshot.ts, SuspendError in src/vm/runtime/execute.ts) now that lazy VM loading is gone, and deleted src/vm/index.ts.
• Tool execution wrappers: Dropped the runtime Object.assign callable wrappers on Tool.idempotent and Tool.durable, the separate Tool.mode field, the synthesized callable tool.execute wrapper in Tool.make, and the fallback runId/nextCallId counter in ToolRuntime.make that only served legacy calls. Tool.Idempotent and Tool.Durable (and Tool<R>["execute"] / ToolRuntime["mode"]) now describe the real runtime tagged-object shapes without a call signature, while internal option types preserve contextual input inference in Tool.make.
• Directory layout: Kept src/vm/ intact as the boundary between Effect-free VM/compiler/snapshot code (enforced by test/vm/state.test.ts) and the Effect host layer in src/.

Config Compatibility

• experimental.codemode_vm and experimental.codemodeVm: Kept a deprecated, ignored experimental.codemode_vm boolean stub on ConfigExperimental.Info (like portable_shell_scanner) so editors validating against config.json (additionalProperties: false) do not flag existing configs, and kept experimental.codemodeVm ignored without diagnostics (covered by packages/core/test/config/normalization.test.ts).
• OPENCODE_FLAGS=codemode_vm: Flag.resolve parses OPENCODE_FLAGS into a map and only reads keys present in ConfigFlag.registry, so codemode_vm or -codemode_vm in OPENCODE_FLAGS is silently ignored.

Verification

• packages/codemode:
  • bun test: 1,633 pass, 0 fail
  • bun run test:roundtrip: 1,632 pass, 1 skip, 0 fail
  • test262 (with local corpus symlinked): 13,329 pass, 1,678 skip, 1 known fail (language/global-code/import.js)
  • bun run typecheck:tsc & bun run pack: clean
• packages/core, packages/server, packages/schema, packages/protocol, packages/client:
  • bun test test/tool-execute.test.ts test/codemode test/flag.test.ts test/config: 339 pass, 1 skip, 0 fail
  • packages/server: bun test test/flag-channel.test.ts: 2 pass, 0 fail
  • bun run typecheck:tsc and check:generated in protocol and client: clean

---

Added by the opencode bot (AI-generated).

Public API: keeps experimental.codemode_vm as a deprecated no-op (backwards compatible); @opencode/codemode drops Engine/engine/VmRuntime/Tool.mode and makes Tool.execute/Idempotent/Durable non-callable tagged types (breaking for library users)

[opencodejr]

The removal looks sound overall. Core now always uses the VM, the single per-inventory runtime cache is correct, and the VM driver dispatches idempotent and durable tools through ToolRuntime.mode, start and wait rather than calling them directly. On the PR head, bun test in packages/codemode passed (1,630) and the core tool, codemode, flag and config tests passed (328). tsc was clean in both packages. I didn't compare test runs with the base or drive the TUI.

Public API impact:

• Config / OpenAPI / client: experimental.codemode_vm is removed from ConfigExperimental and the flag registry, and from the generated openapi.json and client ConfigEntry types. This is backwards compatible: old configs that still set codemode_vm/codemodeVm load with no diagnostics, and OPENCODE_FLAGS=codemode_vm is ignored. The behaviour change is that release builds now always run the VM, with no opt-out.
• @opencode/codemode (breaking for library users):
  • Removed: CodeMode.Engine, Options.engine, the VmRuntime export (now Runtime, which carries program and resume) and the Tool.mode field.
  • Tool.execute is now ExecuteFn | Idempotent | Durable instead of always being callable.
  • ToolRuntime.execute/search/start now require key and admit.

Main concern: Idempotent and Durable still declare a call signature, but the values are no longer callable, so tool.execute(input, ctx) type-checks and then throws at runtime (see inline comment).

[opencodejr]

Idempotent and Durable still declare a call signature (lines 60 and 88) so that inference works, but idempotent() and durable() now return plain objects. That makes tool.execute(input, ctx) type-check for every member of this union, yet it throws execute is not a function at runtime for idempotent and durable tools. I confirmed this with Tool.make({ ..., execute: Tool.idempotent(...) }).execute({}, { key: "k" }). test/openapi.test.ts already has to guard with typeof tool.execute !== "function". Since @opencode/codemode is a published package, could the call signature be kept on a phantom/branded field instead, so the public type matches what the value can actually do?

[opencodejr]

The earlier point (thread 1) isn't addressed yet: Idempotent/Durable still declare a call signature, but the values aren't callable, so tool.execute(input, ctx) still type-checks and then throws. I re-checked this on the new head.

The new commits look sound. CodeModeTool.create no longer takes a flag argument, and Tool.node no longer depends on the flag service; all callers are updated. flag-channel.test.ts now checks only the media_blob channel defaults. On the new head, bun test in packages/codemode (1,633 pass), the core codemode, config and flag tests (340 run, 0 fail) and the server flag-channel test all pass, and tsc is clean in codemode, core and server.

Public API impact is the same as in my last review. experimental.codemode_vm is removed from config, OpenAPI and the client types, and old configs and OPENCODE_FLAGS values are ignored without errors. @opencode/codemode drops Engine, engine, VmRuntime and Tool.mode, and changes the type of Tool.execute, which breaks library users. Removing the flag argument from CodeModeTool.create is internal to core.

[opencodejr]

The earlier point is addressed. Tool.Idempotent, Tool.Durable and the type of Tool.execute no longer have a call signature. Only the option types used by Tool.make for inference keep one, and the new @ts-expect-error check covers this. The new experimental.codemode_vm field is deprecated and does nothing: it's not in the flag registry, so it has no effect, and existing configs still validate in editors. On the new head, bun test in packages/codemode (1,633 pass) and the core config, flag and codemode tests (340 run, 0 fail) pass, and tsc is clean in codemode, core and schema.

Public API impact:

• Config / OpenAPI / client: experimental.codemode_vm stays as a deprecated boolean that does nothing, so this is backwards compatible. codemodeVm and OPENCODE_FLAGS=codemode_vm are ignored. Release builds now always use the VM.
• @opencode/codemode: drops Engine, engine, VmRuntime (now Runtime) and Tool.mode. Tool.execute, Idempotent and Durable are now tagged objects that can't be called directly. This breaks library users who called them.