@vgai/sdk 0.5.1 → 0.5.3

package/src/play/control-operations.ts

@@ -2,25 +2,25 @@
  * `play.seed.set` / `play.timeScale.set`
  * (B4, §8 B4 "deterministic seed and time-scale control").
  *
- * TIME-SCALE is REAL since Wave 5 (docs/SYNTHETIC-PLAYER-SPEC.md §3.5): the
- * `set-time-scale` relay case (`command-listener.ts`) reaches the live
- * session's `GameLoop.timeScale` (`packages/engine/src/core/game-loop.ts`,
- * a live get/set property clamped to `[0, 8]`) through `play-mode.ts`'s
- * `getPlayRuntimeAccess()`, and `collectState` reports the applied value
- * back through `play.status`. `TIME_SCALE_CONTROL_UNSUPPORTED` now fires
- * only against a stale editor page (the structured `UNKNOWN_COMMAND_TYPE`
- * marker, translated to `undefined` by the transport) — or a session where
- * play isn't running, which surfaces as `COMMAND_FAILED`.
+ * TIME-SCALE is REAL since Wave 5: the `set-time-scale` relay case
+ * (`command-listener.ts`) reaches the live session's `GameLoop.timeScale`
+ * (`packages/engine/src/core/game-loop.ts`, a live get/set property clamped
+ * to `[0, 8]`) through `play-mode.ts`'s `getPlayRuntimeAccess()`, and
+ * `collectState` reports the applied value back through `play.status`.
+ * `TIME_SCALE_CONTROL_UNSUPPORTED` now fires only against a stale editor
+ * page (the structured `UNKNOWN_COMMAND_TYPE` marker, translated to
+ * `undefined` by the transport) — or a session where play isn't running,
+ * which surfaces as `COMMAND_FAILED`.
  *
- * SEED is REAL since D15/T-D15.6 (`docs/D15-DETERMINISM-DESIGN.md` §2.d) —
- * no longer an honest gap. `play.seed.set` reaches the live session's
- * `ctx.random.reseed(seed)` (`packages/engine/src/core/seeded-random.ts`,
- * built on T-D15.1's core) through the `set-seed` relay case
- * (`command-listener.ts`) and `play-mode.ts`'s `getPlayRuntimeAccess()`.
- * Semantics are FUTURE-DRAWS-ONLY, matching `SeededRandom.reseed`'s own
- * contract exactly: reseeding mid-run re-derives every live stream so every
- * draw AFTER this call is reproducible from the new seed, but it can never
- * make an already-diverged session's PAST draws reproducible — for a fully
+ * SEED is REAL since D15/T-D15.6 — no longer an honest gap. `play.seed.set`
+ * reaches the live session's `ctx.random.reseed(seed)`
+ * (`packages/engine/src/core/seeded-random.ts`, built on T-D15.1's core)
+ * through the `set-seed` relay case (`command-listener.ts`) and
+ * `play-mode.ts`'s `getPlayRuntimeAccess()`. Semantics are
+ * FUTURE-DRAWS-ONLY, matching `SeededRandom.reseed`'s own contract exactly:
+ * reseeding mid-run re-derives every live stream so every draw AFTER this
+ * call is reproducible from the new seed, but it can never make an
+ * already-diverged session's PAST draws reproducible — for a fully
  * reproducible run, pass the seed at session start instead (manifest
  * `determinism.defaultSeed` / `?vgai-seed=` / `play.start`'s `seed` field /
  * `vgai play --seed` / a probe fixture seed option). Throws the declared
@@ -65,7 +65,7 @@ const DETERMINISM_NOT_DECLARED_ERROR = {
   summary:
     "The running project's manifest does not declare determinism.seededRandom (D15) — " +
     'play.seed.set has no documented determinism contract to reseed against. Declare the ' +
-    'block (docs/D15-DETERMINISM-DESIGN.md §2.a) to opt in.',
+    'block to opt in.',
   data: z.object({}),
 } as const;
 

package/src/play/debug-command-operations.ts

@@ -1,7 +1,6 @@
 /**
- * `play.debugCommand.list` / `play.debugCommand.invoke`
- * (Wave 5, docs/SYNTHETIC-PLAYER-SPEC.md §3.5 — the editor/CLI/MCP door onto
- * `ctx.debug.registerCommand` registrations).
+ * `play.debugCommand.list` / `play.debugCommand.invoke` (Wave 5 — the
+ * editor/CLI/MCP door onto `ctx.debug.registerCommand` registrations).
  *
  * Debug commands are FIXTURES, never proofs (D16): they set up state so a
  * proof can then drive honest input and assert observable state — hence

package/src/play/index.ts

@@ -1,8 +1,7 @@
 /**
- * B4 — `play.*` operations
- * (docs/AI-NATIVE-AUTHORING-IMPLEMENTATION-SPEC.md §8 B4). Registered
- * separately from B1's `registerBuiltinTools` (`../operations.ts`),
- * B2's `registerProjectOperations` (`../project/index.ts`), and B3's
+ * `play.*` operations. Registered separately from B1's
+ * `registerBuiltinTools` (`../operations.ts`), B2's
+ * `registerProjectOperations` (`../project/index.ts`), and B3's
  * `registerEditorOperations` (`../editor/index.ts`) — the default
  * `operations` singleton (`../index.ts`) calls all four.
  */
@@ -16,7 +15,7 @@ export * from './run-ticks-operations.js';
 export * from './state-operations.js';
 export * from './status-operations.js';
 export type {
-  ActiveWorldInfo,
+  ActiveRootInfo,
   InputInjectionKind,
   InputInjectionRequest,
   PlayCommandResult,

package/src/play/input-operations.ts

@@ -1,6 +1,6 @@
 /**
  * `play.input.inject` (B4, §8 B4 "input injection through normal input
- * paths"; wired for real in Wave 5, docs/SYNTHETIC-PLAYER-SPEC.md §3.2/§3.5).
+ * paths"; wired for real in Wave 5).
  *
  * MUST exercise the NORMAL input action path, never a direct game-state
  * mutation (§8 B4 AC). Two tiers, both engine-native:
@@ -11,8 +11,8 @@
  *    actuation surfaces `{delivered: false, reason}` and this op throws the
  *    declared `INPUT_GATED` — never a false ok. Unknown action names throw
  *    `INPUT_ACTION_NOT_FOUND` carrying the declared-action list. `atTick`
- *    (D15/T-D15.5, docs/D15-DETERMINISM-DESIGN.md §2.c) defers the actuation
- *    to `InputManager.scheduleActionAtTick` instead: applied at the START of
+ *    (D15/T-D15.5) defers the actuation to
+ *    `InputManager.scheduleActionAtTick` instead: applied at the START of
  *    that tick's input phase, composing with `play.runTicks`/
  *    `window.__vgai.runTicks` (schedule at tick 500, run 1000 ticks, the
  *    action fires exactly at 500 — a digital `true` produces a genuine
@@ -23,8 +23,8 @@
  *    report yet — the actuation hasn't happened). CAVEAT: a world that is
  *    paused/frozen when its target tick would have been serviced (or is
  *    skipped by a multi-tick gap) silently drops the schedule rather than
- *    applying it late — the only trace is an `'input.schedule.dropped'`
- *    debug event (`{tick, action}`), readable via `play.gameplayState
+ *    applying it late — the only trace is an `'input.schedule.dropped'` debug
+ *    event (`{tick, action}`), readable via `play.gameplayState
  *    .inspect`/`play.debugCommand`'s event surface, not through this op.
  *  - The four legacy named-test-source kinds (`'axis' | 'vector2' |
  *    'pointerDelta' | 'pointerPosition'`) — `InputManager.injectAxis`/
@@ -43,7 +43,7 @@
  * fix): targets a SPECIFIC world's `InputManager` in a multi-world project.
  * Omitted, it resolves to the SAME default world `window.__vgai.input.*`
  * (door a) resolves to — one shared resolution function
- * (`debug-registry.ts`'s `resolveInputWorldId`), so this op and the debug
+ * (`debug-registry.ts`'s `resolveInputRootId`), so this op and the debug
  * bridge can never disagree about which world an unqualified injection
  * targets. An explicit, unregistered `worldId` throws the declared
  * `INPUT_WORLD_NOT_FOUND` (`data.registered` lists every world with a wired
@@ -121,7 +121,7 @@ const COMMAND_FAILED_ERROR = {
 
 const Vector2Schema = z.object({ x: z.number(), y: z.number() });
 
-const WorldIdField = z
+const RootIdField = z
   .string()
   .optional()
   .describe(
@@ -157,13 +157,13 @@ const PlayInputInjectInput = z
             'with play.runTicks/window.__vgai.runTicks. Throws TICK_ALREADY_PASSED for a tick ' +
             'that already elapsed in the running session.',
         ),
-      worldId: WorldIdField,
+      worldId: RootIdField,
     }),
     z.object({
       kind: z.literal('axis'),
       sourceId: z.string().describe('Named test-input source id an action binds to (test_axis).'),
       value: z.number().describe('Raw scalar value (same units InputManager.injectAxis takes).'),
-      worldId: WorldIdField,
+      worldId: RootIdField,
     }),
     z.object({
       kind: z.literal('vector2'),
@@ -171,7 +171,7 @@ const PlayInputInjectInput = z
         .string()
         .describe('Named test-input source id an action binds to (test_vector2).'),
       value: Vector2Schema,
-      worldId: WorldIdField,
+      worldId: RootIdField,
     }),
     z.object({
       kind: z.literal('pointerDelta'),
@@ -179,7 +179,7 @@ const PlayInputInjectInput = z
         .string()
         .describe('Named test-input source id an action binds to (test_pointer_delta).'),
       value: Vector2Schema,
-      worldId: WorldIdField,
+      worldId: RootIdField,
     }),
     z.object({
       kind: z.literal('pointerPosition'),
@@ -187,7 +187,7 @@ const PlayInputInjectInput = z
         .string()
         .describe('Named test-input source id an action binds to (test_pointer_position).'),
       value: Vector2Schema,
-      worldId: WorldIdField,
+      worldId: RootIdField,
     }),
   ])
   .describe(

package/src/play/lifecycle-operations.ts

@@ -12,7 +12,7 @@
  * readiness or a named timeout"): `case 'play'` in `handleCommand`
  * `await`s `enterPlayMode()` — which itself awaits the ENTIRE async game
  * boot (asset loads, procedural worldgen, `createGameRuntime`/
- * `mountManifestWorlds`) — before acking back over
+ * `mountManifestRoots`) — before acking back over
  * `POST /__editor/command-result`. That ack is what unblocks the relay's
  * HTTP response. So `play.start`'s `impl` genuinely does not resolve before
  * the runtime is ready: it `await`s the transport call, and the transport
@@ -101,8 +101,8 @@ const PlayStartInput = z.object({
     .describe(
       'D15/T-D15.6 — the explicit-config leg of the boot-time deterministic-seed precedence ' +
         '(beats manifest.determinism.defaultSeed/?vgai-seed= on the editor page URL); baked in ' +
-        'before any world mounts (`enterPlayMode`/`mountManifestWorlds`, not a post-hoc reseed). ' +
-        'Mirrors `vgai play --seed <n>` — see docs/D15-DETERMINISM-DESIGN.md §2.d.',
+        'before any world mounts (`enterPlayMode`/`mountManifestRoots`, not a post-hoc reseed). ' +
+        'Mirrors `vgai play --seed <n>`.',
     ),
 });
 

package/src/play/run-ticks-operations.ts

@@ -1,8 +1,8 @@
 /**
- * `play.runTicks` (D15/T-D15.4, `docs/D15-DETERMINISM-DESIGN.md` §2.b) — the
- * editor door (b) of the same run-ticks primitive `window.__vgai.runTicks`
- * (door a, `runtime/debug-bridge.ts`) exposes: synchronously fast-forward a
- * running play session `n` fixed gameplay ticks, decoupled from wall clock.
+ * `play.runTicks` (D15/T-D15.4) — the editor door (b) of the same run-ticks
+ * primitive `window.__vgai.runTicks` (door a, `runtime/debug-bridge.ts`)
+ * exposes: synchronously fast-forward a running play session `n` fixed
+ * gameplay ticks, decoupled from wall clock.
  *
  * Wire: relay case `run-ticks` (`command-listener.ts`) reaching the live
  * session's `GameInternal.runTicks` through `play-mode.ts`'s

package/src/play/state-operations.ts

@@ -1,7 +1,7 @@
 /**
- * `play.gameplayState.inspect` / `play.gameplayState.list`
- * (B4, §8 B4 "gameplay state/test-hook inspection when provided by the game";
- * implemented for real in Wave 5, docs/SYNTHETIC-PLAYER-SPEC.md §3.5).
+ * `play.gameplayState.inspect` / `play.gameplayState.list` (B4, §8 B4
+ * "gameplay state/test-hook inspection when provided by the game";
+ * implemented for real in Wave 5).
  *
  * The registration mechanism this file's old HONEST-GAP jsdoc anticipated
  * now exists: games register named state providers via
@@ -97,7 +97,7 @@ export const playGameplayStateInspect = defineTool({
   summary: 'Inspect game-registered state providers from a running play session.',
   description:
     'Reads named state providers a game registered via ctx.debug.registerStateProvider ' +
-    '(docs/SYNTHETIC-PLAYER-SPEC.md §3.1) from the live editor play session, through the ' +
+    'from the live editor play session, through the ' +
     'inspect-gameplay-state relay command. `keys` are provider names; omitting them returns ' +
     'one coherent snapshot of every provider. Returns { state: null } when the running game ' +
     'exposes no debug adapter; throws GAMEPLAY_STATE_UNSUPPORTED against a stale editor page.',

package/src/play/status-operations.ts

@@ -1,5 +1,5 @@
 /**
- * `play.status` / `play.activeWorld.inspect` (B4, §8 B4 "status and
+ * `play.status` / `play.activeRoot.inspect` (B4, §8 B4 "status and
  * active-world inspection").
  *
  * status.playState is genuinely wired: `GET /__editor/state`'s `playState`
@@ -11,11 +11,11 @@
  * .timeScale`; each is `null`/`false` only when no session/Game is running
  * or a prior `play.seed.set`/`play.timeScale.set` never succeeded.
  *
- * `activeWorld.inspect` is a full HONEST GAP: `collectState()` carries no
+ * `activeRoot.inspect` is a full HONEST GAP: `collectState()` carries no
  * world id/kind field at all today (only a scalar `entityCount` and the
  * other UI-state fields already listed in `../editor/transport.ts`'s
  * jsdoc) — the live wire protocol has nothing to report. A test transport
- * can supply a real `ActiveWorldInfo`, proving the result schema round-trips
+ * can supply a real `ActiveRootInfo`, proving the result schema round-trips
  * end to end (see `../../test/play-operations.test.ts`).
  */
 
@@ -108,27 +108,27 @@ export const playStatus = defineTool({
 });
 
 // ---------------------------------------------------------------------------
-// play.activeWorld.inspect
+// play.activeRoot.inspect
 // ---------------------------------------------------------------------------
 
-const PlayActiveWorldInspectInput = z
+const PlayActiveRootInspectInput = z
   .object({})
   .describe('No input — inspects the active world of the running play session.');
 
-const PlayActiveWorldInspectResult = z.object({
+const PlayActiveRootInspectResult = z.object({
   worldId: z.string(),
   worldKind: z.string(),
 });
 
-export const playActiveWorldInspect = defineTool({
-  name: 'play.activeWorld.inspect',
+export const playActiveRootInspect = defineTool({
+  name: 'play.activeRoot.inspect',
   summary: 'Inspect the active world of a running play session (id/kind).',
   description:
     'Real wire protocol has no world data today (see module jsdoc) — always throws the declared ' +
     'ACTIVE_WORLD_UNAVAILABLE against the real transport; a test transport can supply real data, ' +
     'proving the result schema round-trips end to end.',
-  input: PlayActiveWorldInspectInput,
-  result: PlayActiveWorldInspectResult,
+  input: PlayActiveRootInspectInput,
+  result: PlayActiveRootInspectResult,
   errors: [PLAY_RUNTIME_NOT_AVAILABLE_ERROR, ACTIVE_WORLD_UNAVAILABLE_ERROR],
   requires: { editor: true, play: true },
   host: 'runtime-page',
@@ -139,9 +139,9 @@ export const playActiveWorldInspect = defineTool({
     const transport = getPlayTransport(ctx);
     const session = await resolvePlaySession(ctx, transport);
     const world = await withPlayTimeout(
-      transport.getActiveWorld(session, PLAY_READ_TIMEOUT_MS),
+      transport.getActiveRoot(session, PLAY_READ_TIMEOUT_MS),
       PLAY_READ_TIMEOUT_MS,
-      'play.activeWorld.inspect',
+      'play.activeRoot.inspect',
     ).catch(() => undefined);
     if (!world) {
       throw new ToolError(
@@ -156,5 +156,5 @@ export const playActiveWorldInspect = defineTool({
 
 export function registerStatusOperations(registry: ToolRegistry): void {
   registry.register(playStatus);
-  registry.register(playActiveWorldInspect);
+  registry.register(playActiveRootInspect);
 }

package/src/play/transport.ts

@@ -1,6 +1,5 @@
 /**
- * Transport seam for B4's `play.*` operations
- * (docs/AI-NATIVE-AUTHORING-IMPLEMENTATION-SPEC.md §8 B4).
+ * Transport seam for B4's `play.*` operations.
  *
  * `play.*` targets or launches a playable runtime (§5.7). TODAY, the only
  * playable runtime this repo can launch/target is the one already mounted
@@ -17,8 +16,8 @@
  * (these ops target/launch a playable runtime, which is the host
  * classification's whole point), while the REAL transport underneath rides
  * the existing editor-browser relay — see each op file's jsdoc for exactly
- * which relay call it reuses, and PLAY-GAPS.md-style notes below for what
- * has no relay wiring today.
+ * which relay call it reuses, and the notes below for what has no relay
+ * wiring today.
  *
  * SESSION RESOLUTION: `resolvePlaySession` mirrors
  * `../editor/transport.ts`'s `resolveEditorSession` byte-for-byte in
@@ -32,17 +31,16 @@
  * module jsdoc documents for its session-registry reader — a few lines
  * duplicated beats a much larger, unrelated interface coupling.
  *
- * REAL TRANSPORT SURFACE — what `HttpPlayTransport` actually talks to.
- * Wave 5 (docs/SYNTHETIC-PLAYER-SPEC.md §3.5) closed the version-skew lie:
- * `command-listener.ts`'s `handleCommand` now has a `default:` case answering
- * `{ok:false, data:{code:'UNKNOWN_COMMAND_TYPE'}}` for any command type the
- * connected editor page predates, and the relay's result leg carries `data`
- * end to end (`reportCommandResult` → `/__editor/command-result` →
- * `commandResponseFor` → `relayCommand` below). Methods here translate that
- * structured marker into `undefined` — the undefined-means-unsupported
- * convention `editor/transport.ts`'s `openStory`/`getCamera` established —
- * so each op throws its own declared `*_UNSUPPORTED` code against a stale
- * editor, never trusting a fabricated ack.
+ * REAL TRANSPORT SURFACE — what `HttpPlayTransport` actually talks to. Wave 5
+ * closed the version-skew lie: `command-listener.ts`'s `handleCommand` now has
+ * a `default:` case answering `{ok:false, data:{code:'UNKNOWN_COMMAND_TYPE'}}`
+ * for any command type the connected editor page predates, and the relay's
+ * result leg carries `data` end to end (`reportCommandResult` →
+ * `/__editor/command-result` → `commandResponseFor` → `relayCommand` below).
+ * Methods here translate that structured marker into `undefined` — the
+ * undefined-means-unsupported convention `editor/transport.ts`'s
+ * `openStory`/`getCamera` established — so each op throws its own declared
+ * `*_UNSUPPORTED` code against a stale editor, never trusting a fabricated ack.
  *
  *  - start/pause/resume/stop/frameStep: `POST /__editor/command` with
  *    `{type:'play'|'stop'|'pause'|'resume'|'step'}` — ALL FIVE are real,
@@ -172,8 +170,6 @@ export interface PlaySessionInfo {
   port: number;
   project: string | null;
   pid: number | null;
-  /** Registry discriminator. `kind: 'e2e'` is standalone and cannot host editor-relayed play control. */
-  kind?: string;
   /** Exact explicitly targeted editor origin/base URL, including protocol and host. */
   url?: string;
 }
@@ -218,14 +214,13 @@ export interface PlayStatus {
    *  `determinism.seededRandom` (D15) — i.e. `play.seed.set`/the
    *  `gameplay-rng-ban` scan/the dev-mode RNG trap all apply to it. `false`
    *  for an undeclared project even though `ctx.random` still exists (it
-   *  just isn't a documented contract — see `docs/D15-DETERMINISM-DESIGN.md`
-   *  §2.a). */
+   *  just isn't a documented contract). */
   deterministic: boolean;
   /** Currently-applied simulation time-scale, when known — null when never successfully set (see `control-operations.ts`'s honest gap). */
   timeScale: number | null;
 }
 
-export interface ActiveWorldInfo {
+export interface ActiveRootInfo {
   worldId: string;
   worldKind: string;
 }
@@ -298,7 +293,7 @@ export interface PlayTransport {
   frameStep(session: PlaySessionInfo, timeoutMs: number): Promise<PlayCommandResult>;
   getStatus(session: PlaySessionInfo, timeoutMs: number): Promise<PlayStatus | undefined>;
   /** Honest gap against the real transport — see `status-operations.ts`. */
-  getActiveWorld(session: PlaySessionInfo, timeoutMs: number): Promise<ActiveWorldInfo | undefined>;
+  getActiveRoot(session: PlaySessionInfo, timeoutMs: number): Promise<ActiveRootInfo | undefined>;
   getLogFollowMetadata(
     session: PlaySessionInfo,
     timeoutMs: number,
@@ -312,9 +307,9 @@ export interface PlayTransport {
     timeoutMs: number,
   ): Promise<PlayCommandResult | undefined>;
   /**
-   * D15/T-D15.6 (`docs/D15-DETERMINISM-DESIGN.md` §2.d): real since this
-   * track — relay case `set-seed` (`command-listener.ts`) reaching the live
-   * session's `ctx.random.reseed(seed)` through `play-mode.ts`'s
+   * D15/T-D15.6: real since this track — relay case `set-seed`
+   * (`command-listener.ts`) reaching the live session's
+   * `ctx.random.reseed(seed)` through `play-mode.ts`'s
    * `getPlayRuntimeAccess()`. FUTURE DRAWS ONLY (reseeding mid-run can never
    * make an already-diverged session reproducible — for that, seed at
    * session start instead). `undefined` only against a stale editor page
@@ -368,13 +363,12 @@ export interface PlayTransport {
     timeoutMs: number,
   ): Promise<PlayCommandResult | undefined>;
   /**
-   * D15/T-D15.4 (`docs/D15-DETERMINISM-DESIGN.md` §2.b): real since this
-   * track — relay case `run-ticks` (`command-listener.ts`) reaching the live
-   * session's `GameInternal.runTicks` through `play-mode.ts`'s
-   * `getPlayRuntimeAccess()`. Success is a plain `{ok: true}` (no data leg);
-   * `undefined` only against a stale editor page (`UNKNOWN_COMMAND_TYPE`
-   * marker). Structured failures (`RUN_TICKS_PAUSED`, `RUN_TICKS_UNAVAILABLE`)
-   * ride `data.code`.
+   * D15/T-D15.4: real since this track — relay case `run-ticks`
+   * (`command-listener.ts`) reaching the live session's
+   * `GameInternal.runTicks` through `play-mode.ts`'s `getPlayRuntimeAccess()`.
+   * Success is a plain `{ok: true}` (no data leg); `undefined` only against a
+   * stale editor page (`UNKNOWN_COMMAND_TYPE` marker). Structured failures
+   * (`RUN_TICKS_PAUSED`, `RUN_TICKS_UNAVAILABLE`) ride `data.code`.
    */
   runTicks(
     session: PlaySessionInfo,
@@ -426,7 +420,6 @@ function readRegisteredSessions(): RegistrySessionEntry[] {
     return Array.isArray(raw)
       ? raw
           .filter(isRegistrySessionEntry)
-          .filter((s) => s.kind !== 'e2e')
           .filter((s) => pidAlive(s.pid))
       : [];
   } catch {
@@ -492,7 +485,7 @@ async function postJson(url: string, body: unknown, timeoutMs: number): Promise<
 }
 
 function baseUrl(session: PlaySessionInfo): string {
-  return session.url ?? `http://localhost:${session.port}`;
+  return session.url ?? `http://127.0.0.1:${session.port}`;
 }
 
 async function relayCommand(
@@ -558,7 +551,7 @@ export class HttpPlayTransport implements PlayTransport {
     const probes = await Promise.all(
       registered.map(async (s) => {
         const body = await fetchJson(
-          `http://localhost:${s.port}/__editor/project`,
+          `http://127.0.0.1:${s.port}/__editor/project`,
           perProbeTimeout,
         );
         if (body === undefined) return undefined;
@@ -567,7 +560,6 @@ export class HttpPlayTransport implements PlayTransport {
           port: s.port,
           project,
           pid: s.pid,
-          ...(s.kind !== undefined ? { kind: s.kind } : {}),
         };
         return info;
       }),
@@ -627,10 +619,10 @@ export class HttpPlayTransport implements PlayTransport {
     };
   }
 
-  async getActiveWorld(
+  async getActiveRoot(
     _session: PlaySessionInfo,
     _timeoutMs: number,
-  ): Promise<ActiveWorldInfo | undefined> {
+  ): Promise<ActiveRootInfo | undefined> {
     // `collectState()` (command-listener.ts) carries no world field today —
     // honest gap, never a fabricated world id (see status-operations.ts).
     return undefined;
@@ -819,7 +811,6 @@ export async function resolvePlaySession(
   } catch {
     return notRunning();
   }
-  sessions = sessions.filter((session) => session.kind !== 'e2e');
   if (sessions.length === 0) return notRunning();
 
   if (editorUrl !== undefined) {

package/src/project/index.ts

@@ -1,36 +1,29 @@
 /**
- * B2 — `project.*` operations
- * (docs/AI-NATIVE-AUTHORING-IMPLEMENTATION-SPEC.md §8 B2). Registered
- * SEPARATELY from B1's `registerBuiltinTools` (see `../operations.ts`)
- * so B1's own registry tests — which assert `registerBuiltinTools`
- * registers "exactly the three B1 sample operations" — are unaffected; the
- * default `operations` singleton (`../index.ts`) calls both.
+ * `project.*` operations. Registered SEPARATELY from B1's
+ * `registerBuiltinTools` (see `../operations.ts`) so B1's own registry
+ * tests — which assert `registerBuiltinTools` registers "exactly the three
+ * B1 sample operations" — are unaffected; the default `operations`
+ * singleton (`../index.ts`) calls both.
  */
 
 export * from './asset-operations.js';
-export * from './component-operations.js';
 export * from './discovery-operations.js';
-export * from './entity-operations.js';
 export * from './input-map-operations.js';
 export * from './inspection.js';
 export * from './inspection-operation.js';
 export * from './manifest-operations.js';
 export * from './provenance.js';
-export * from './scene-operations.js';
 export {
   BaseHashField,
   CONFLICT_ERROR,
   checkNotStale,
   DryRunField,
-  ENTITY_NOT_FOUND_ERROR,
   FILE_NOT_FOUND_ERROR,
-  findEntityById,
   listProjectFiles,
   mutationResultSchema,
   NO_PROJECT_ROOT_ERROR,
   PATH_OUTSIDE_PROJECT_ERROR,
   readFileWithHash,
-  requireEntityById,
   requireProjectRoot,
   resolveProjectPath,
   sha256Hex,
@@ -39,20 +32,23 @@ export {
 
 import type { ToolRegistry } from '../registry.js';
 import { registerAssetOperations } from './asset-operations.js';
-import { registerComponentOperations } from './component-operations.js';
 import { registerDiscoveryOperations } from './discovery-operations.js';
-import { registerEntityOperations } from './entity-operations.js';
 import { registerInputMapOperations } from './input-map-operations.js';
 import { registerInspectionOperations } from './inspection-operation.js';
 import { registerManifestOperations } from './manifest-operations.js';
-import { registerSceneOperations } from './scene-operations.js';
 
-/** Register every B2 `project.*` operation onto `registry`. */
+/**
+ * Register every B2 `project.*` operation onto `registry`.
+ *
+ * WO-8 removed the twelve `.vscn` document tools:
+ * `project.scene.{read,validate,diff,apply}`,
+ * `project.scene.entity.{add,update,move,remove}` and
+ * `project.scene.component.{list,add,update,remove}`. They read and wrote the
+ * deleted scene format; a three root is authored as TSX source now, so the source
+ * tools (`project.file.*` / the editor's own adapter seam) are what act on it.
+ */
 export function registerProjectOperations(registry: ToolRegistry): void {
   registerManifestOperations(registry);
-  registerSceneOperations(registry);
-  registerEntityOperations(registry);
-  registerComponentOperations(registry);
   registerAssetOperations(registry);
   registerInputMapOperations(registry);
   registerDiscoveryOperations(registry);

package/src/project/inspection-node.ts

@@ -1,7 +1,7 @@
 /** Node filesystem binding for the shared, read-only project inspector. */
 
 import { readdir, readFile, stat, writeFile } from 'node:fs/promises';
-import { basename, join, resolve } from 'node:path';
+import { basename, resolve } from 'node:path';
 import {
   createIngestManifest,
   inspectProject,
@@ -9,6 +9,7 @@ import {
   type ProjectInspectionReader,
   type SuggestedAdapterSurface,
 } from './inspection.js';
+import { resolveManifestPath } from '../../../engine/src/manifest/locate.js';
 import { resolveProjectPath } from './shared.js';
 
 export type { SuggestedAdapterSurface } from './inspection.js';
@@ -56,17 +57,17 @@ export async function adaptProjectFolderPath(
     surface?: SuggestedAdapterSurface | undefined;
     entry?: string | undefined;
   },
-): Promise<{ path: string; writes: ['vgai.game.json']; manifest: Record<string, unknown> }> {
+): Promise<{ path: string; writes: ['vgai.project.json']; manifest: Record<string, unknown> }> {
   const preview = await previewAdaptProjectFolderPath(path, options);
   await writeFile(
-    join(preview.path, 'vgai.game.json'),
+    resolveManifestPath(preview.path),
     `${JSON.stringify(preview.manifest, null, 2)}\n`,
     {
       encoding: 'utf-8',
       flag: 'wx',
     },
   );
-  return { path: preview.path, writes: ['vgai.game.json'], manifest: preview.manifest };
+  return { path: preview.path, writes: ['vgai.project.json'], manifest: preview.manifest };
 }
 
 /** Build the exact proposed sidecar without writing it. */
@@ -87,7 +88,7 @@ export async function previewAdaptProjectFolderPath(
   const rootStat = await stat(root);
   if (!rootStat.isDirectory()) throw new Error(`Project path is not a directory: ${root}`);
   const report = await inspectProject(nodeProjectInspectionReader(root));
-  if (report.hasManifest) throw new Error('This folder already has a vgai.game.json manifest.');
+  if (report.hasManifest) throw new Error('This folder already has a vgai.project.json manifest.');
   let name = basename(root);
   try {
     const packageJson = JSON.parse(

package/src/project/inspection-operation.ts

@@ -9,7 +9,7 @@ import { NO_PROJECT_ROOT_ERROR, requireProjectRoot } from './shared.js';
 const ProjectInspectionResult = z.object({
   workspaceState: z.enum(['vgai-project', 'adaptable-project', 'empty-folder', 'unknown-project']),
   detectedTechnologies: z.array(z.string()),
-  suggestedSurface: z.enum(['threejs', 'pixijs', 'react']).nullable(),
+  suggestedSurface: z.enum(['three', 'canvas', 'dom']).nullable(),
   entryCandidates: z.array(z.string()),
   adaptationBlockers: z.array(z.string()),
   hasManifest: z.boolean(),

package/src/project/inspection.ts

@@ -9,7 +9,7 @@ export type ProjectWorkspaceState =
   | 'empty-folder'
   | 'unknown-project';
 
-export type SuggestedAdapterSurface = 'threejs' | 'pixijs' | 'react';
+export type SuggestedAdapterSurface = 'three' | 'canvas' | 'dom';
 
 export interface ProjectInspection {
   workspaceState: ProjectWorkspaceState;
@@ -135,7 +135,7 @@ function candidateEntries(files: string[]): string[] {
 /** Inspect a folder without mutating it or assuming that it is already VGAI-shaped. */
 // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: one ordered evidence-to-recommendation decision table.
 export async function inspectProject(reader: ProjectInspectionReader): Promise<ProjectInspection> {
-  if (await reader.exists('vgai.game.json')) {
+  if (await reader.exists('vgai.project.json')) {
     return {
       workspaceState: 'vgai-project',
       detectedTechnologies: ['VGAI'],
@@ -181,18 +181,18 @@ export async function inspectProject(reader: ProjectInspectionReader): Promise<P
   const suggestedSurface: SuggestedAdapterSurface | null = technologies.some(
     (name) => name === 'three.js' || name === 'React Three Fiber',
   )
-    ? 'threejs'
+    ? 'three'
     : technologies.includes('PixiJS')
-      ? 'pixijs'
+      ? 'canvas'
       : technologies.includes('React')
-        ? 'react'
+        ? 'dom'
         : null;
   const entries = candidateEntries(files);
   const adaptationBlockers: string[] = [];
   if (suggestedSurface && entries.length === 0) {
     adaptationBlockers.push('No JavaScript or TypeScript entry candidate was found.');
   }
-  if (suggestedSurface === 'react' && entries[0]) {
+  if (suggestedSurface === 'dom' && entries[0]) {
     let entrySource = '';
     try {
       entrySource = await reader.read(entries[0]);