@vgai/sdk 0.5.2 → 0.5.3

package/package.json

@@ -2,7 +2,7 @@
   "name": "@vgai/sdk",
   "author": "Volter AI, Inc.",
   "license": "Apache-2.0",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "type": "module",
   "repository": {
     "type": "git",
@@ -26,8 +26,8 @@
     "./tools": "./src/tools.ts"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "@vgai/engine": "0.5.2",
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@vgai/engine": "0.5.3",
     "playwright": "^1.58.2",
     "zod": "^4.3.6"
   }

package/src/account.ts

@@ -37,6 +37,23 @@ export const AccountUserSchema = z.object({
   email: z.string().email(),
   name: z.string().min(1).optional(),
 });
+export const AccountOrganizationDomainSchema = z.object({
+  name: z.string().min(1),
+  verified: z.boolean(),
+  enrollmentMode: z.enum([
+    'manual_invitation',
+    'automatic_invitation',
+    'automatic_suggestion',
+    'enterprise_sso',
+  ]),
+});
+export const AccountOrganizationSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  slug: z.string().min(1).optional(),
+  role: z.string().min(1),
+  domains: z.array(AccountOrganizationDomainSchema).max(50),
+});
 export const AccountUsageEntrySchema = z.object({
   id: z.string().min(1),
   occurredAt: z.string().datetime(),
@@ -53,6 +70,7 @@ export const AccountSnapshotSchema = z.discriminatedUnion('authenticated', [
     authenticated: z.literal(true),
     backend: AccountBackendSchema,
     user: AccountUserSchema,
+    organizations: z.array(AccountOrganizationSchema).max(100).optional(),
     plan: AccountPlanSchema,
     credits: AccountCreditsSchema,
     spendPolicy: AccountSpendPolicySchema,
@@ -89,6 +107,8 @@ export type AccountPlan = z.infer<typeof AccountPlanSchema>;
 export type AccountCredits = z.infer<typeof AccountCreditsSchema>;
 export type AccountSpendPolicy = z.infer<typeof AccountSpendPolicySchema>;
 export type AccountUser = z.infer<typeof AccountUserSchema>;
+export type AccountOrganization = z.infer<typeof AccountOrganizationSchema>;
+export type AccountOrganizationDomain = z.infer<typeof AccountOrganizationDomainSchema>;
 export type AccountUsageEntry = z.infer<typeof AccountUsageEntrySchema>;
 export type AccountSnapshot = z.infer<typeof AccountSnapshotSchema>;
 export type GenerationExecutionRoute = z.infer<typeof GenerationExecutionRouteSchema>;

package/src/cinematic/gsap-operations.ts

@@ -4,7 +4,7 @@
  *
  * DECISION (per this unit's brief — "static/metadata where possible; named
  * error if runtime-only"): this is STATIC-ONLY, by design, not a wiring gap.
- * `registerGsap` (`packages/engine/src/animation/gsap-registration.ts`)
+ * `registerGsap` (`packages/editor/catalog/project-source/src/lib/timeline/gsap-registration.ts`)
  * stores its bookkeeping in a module-private
  * `WeakMap<AnimationClock, WeakSet<gsap.core.Timeline>>` — deliberately
  * un-enumerable (no `.list()`/registry object is exported at all, so that
@@ -13,7 +13,7 @@
  * live surface — local or over any wire protocol — that could ever answer
  * "what GSAP timelines are registered on this running clock right now",
  * independent of this unit's file-ownership boundary (that WeakMap is
- * `packages/engine/src/animation/gsap-registration.ts`, not
+ * `packages/editor/catalog/project-source/src/lib/timeline/gsap-registration.ts`, not
  * `vgai-sdk`, and adding an enumeration API to it is out of this unit's
  * scope regardless). So the honest, useful thing this op CAN do is exactly
  * what B2's `project.xstate.discover` does for XState machines
@@ -77,7 +77,7 @@ export const cinematicGsapInspect = defineTool({
     'deterministic GSAP timeline.',
   description:
     'STATIC-ONLY BY DESIGN, not a wiring gap — see module jsdoc. registerGsap’s bookkeeping is an ' +
-    'un-enumerable WeakMap/WeakSet (packages/engine/src/animation/gsap-registration.ts), so no ' +
+    'un-enumerable WeakMap/WeakSet (packages/editor/catalog/project-source/src/lib/timeline/gsap-registration.ts), so no ' +
     'live "what is registered right now" surface exists anywhere to poll instead.',
   input: CinematicGsapInspectInput,
   result: CinematicGsapInspectResult,

package/src/cinematic/index.ts

@@ -1,8 +1,7 @@
 /**
- * B5 — `cinematic.*` operations
- * (docs/AI-NATIVE-AUTHORING-IMPLEMENTATION-SPEC.md §8 B5). Registered
- * separately from B1's `registerBuiltinTools` (`../operations.ts`),
- * B2's `registerProjectOperations` (`../project/index.ts`), B3's
+ * `cinematic.*` operations. Registered separately from B1's
+ * `registerBuiltinTools` (`../operations.ts`), B2's
+ * `registerProjectOperations` (`../project/index.ts`), B3's
  * `registerEditorOperations` (`../editor/index.ts`), and B4's
  * `registerPlayOperations` (`../play/index.ts`) — the default `operations`
  * singleton (`../index.ts`) calls all five.

package/src/cinematic/theatre-operations.ts

@@ -11,7 +11,7 @@
  * (§5.7), which in practice is very often NOT inside a vgai game project at
  * all — the committed reference fixtures this unit proves against
  * (`packages/engine/e2e/{reference,render}-cinematic/theatre-project.json`)
- * are engine e2e fixtures with no `vgai.game.json` anywhere above them. So
+ * are engine e2e fixtures with no `vgai.project.json` anywhere above them. So
  * these ops take an explicit `root` (falling back to `ctx.projectRoot` when
  * omitted) rather than being HARD-confined to `ctx.projectRoot` the way
  * `project.*` ops are — there is deliberately no `PATH_OUTSIDE_PROJECT`-style

package/src/editor/index.ts

@@ -1,14 +1,14 @@
 /**
- * B3 — `editor.*` operations
- * (docs/AI-NATIVE-AUTHORING-IMPLEMENTATION-SPEC.md §8 B3). Registered
- * separately from B1's `registerBuiltinTools` (`../operations.ts`) and
- * B2's `registerProjectOperations` (`../project/index.ts`) — the default
+ * `editor.*` operations. Registered separately from B1's
+ * `registerBuiltinTools` (`../operations.ts`) and B2's
+ * `registerProjectOperations` (`../project/index.ts`) — the default
  * `operations` singleton (`../index.ts`) calls all three.
  */
 
 export * from './camera-operations.js';
 export * from './console-operations.js';
 export * from './hierarchy-operations.js';
+export * from './inspection-operations.js';
 export * from './open-operations.js';
 export * from './screenshot-operations.js';
 export * from './selection-operations.js';
@@ -23,6 +23,11 @@ export type {
   EditorTransport,
   HierarchyNodeInfo,
   HierarchySummary,
+  InspectedActionInfo,
+  InspectedFieldInfo,
+  InspectedSectionBodyInfo,
+  InspectedSectionInfo,
+  InspectedSubjectInfo,
   OidSourceEntry,
   ScreenshotResult,
 } from './transport.js';
@@ -43,6 +48,7 @@ import type { ToolRegistry } from '../registry.js';
 import { registerCameraOperations } from './camera-operations.js';
 import { registerConsoleOperations } from './console-operations.js';
 import { registerHierarchyOperations } from './hierarchy-operations.js';
+import { registerEditorInspectionOperations } from './inspection-operations.js';
 import { registerOpenOperations } from './open-operations.js';
 import { registerScreenshotOperations } from './screenshot-operations.js';
 import { registerSelectionOperations } from './selection-operations.js';
@@ -54,6 +60,7 @@ export function registerEditorOperations(registry: ToolRegistry): void {
   registerSessionOperations(registry);
   registerSelectionOperations(registry);
   registerHierarchyOperations(registry);
+  registerEditorInspectionOperations(registry);
   registerCameraOperations(registry);
   registerSourceLocationOperations(registry);
   registerOpenOperations(registry);

package/src/editor/inspection-operations.ts

@@ -0,0 +1,189 @@
+/**
+ * `editor.inspection.get` — the SERIALIZED inspection subject, as an
+ * operation (design: `docs/ARCHITECTURE-CORE.md` §Editor chrome, "The
+ * Inspection Model"; build ledger: `docs/WORK.md` §Inspection Model program,
+ * W4).
+ *
+ * The inspection model's fourth projection: where the column and the compact
+ * card render the subject, this one reports it as data. Same composer, same
+ * live state, same section identity and order — a `fields` section carries
+ * the CURRENT VALUE at each field's scriptable `path`, read through the same
+ * io the field rows edit through, and a `custom` body is a named opaque
+ * (`{kind:'custom', id, title}`) because the editor renders those with React
+ * and there is nothing honest to put on a wire for them — except the values a
+ * section can state itself (`data`; the Transform section's
+ * position/rotation/scale, which no other read could reach).
+ *
+ * "The same subject a human reads" includes reading NO subject: when the
+ * inspector is unmounted this answers {@link NothingInspectedSchema}'s
+ * `{none:true}` rather than a nominal placeholder.
+ *
+ * Naming: this registry's idiom is `editor.<domain>.<verb>`
+ * (`editor.selection.get`, `editor.hierarchy.inspect`,
+ * `editor.viewport.camera.get`), so the operation is `editor.inspection.get`.
+ * The design's `editor.inspect` spelling is the `@vgai/live` verb over the
+ * same wire — `vgai eval 'editor.inspect()'` — where `editor` is the session
+ * facade and `inspect` is its method.
+ *
+ * Wired end to end: `POST /__editor/command` `{type:'inspect'}`, a real,
+ * already-handled case in the browser's `handleCommand` switch
+ * (`packages/editor/src/command-listener.ts`). A session with no attached
+ * browser tab fails `INSPECTION_UNAVAILABLE` — never an empty subject, which
+ * would read as "nothing to inspect" and be a fabrication.
+ */
+
+import { z } from 'zod';
+import { ToolError } from '../errors.js';
+import { defineTool, type ToolRegistry } from '../registry.js';
+import {
+  EDITOR_COMMAND_TIMEOUT_MS,
+  EDITOR_NOT_RUNNING_ERROR,
+  getTransport,
+  resolveEditorSession,
+  withTimeout,
+} from './transport.js';
+
+const INSPECTION_UNAVAILABLE_ERROR = {
+  code: 'INSPECTION_UNAVAILABLE',
+  summary: 'A session is connected but no browser tab answered the inspection read in time.',
+  data: z.object({}),
+} as const;
+
+const InspectedFieldSchema = z.object({
+  path: z.string().describe('Stable scriptable address of this field.'),
+  label: z.string(),
+  type: z.string().describe('Field kind: string|number|boolean|vec3|color|enum|asset|json.'),
+  value: z
+    .unknown()
+    .optional()
+    .describe('Current value at `path`. Absent when unset, or when `mixed` is set.'),
+  mixed: z
+    .literal(true)
+    .optional()
+    .describe('The inspected subjects DISAGREE about this field (the model’s MIXED sentinel).'),
+  defaulted: z
+    .boolean()
+    .optional()
+    .describe('The value shown is the declared default — the document does not carry it.'),
+  readonly: z.boolean().optional(),
+  resettable: z.boolean().optional(),
+  revertsTo: z.string().optional(),
+  group: z.string().optional(),
+  options: z.array(z.unknown()).optional(),
+});
+
+const InspectedSectionSchema = z.object({
+  id: z.string().describe('Stable section id — the compact card’s persisted tab key.'),
+  title: z.string(),
+  order: z.number().describe('Display order; sections are already sorted by it.'),
+  description: z.string().optional(),
+  body: z
+    .union([
+      z.object({ kind: z.literal('fields'), fields: z.array(InspectedFieldSchema) }),
+      z.object({
+        kind: z.literal('custom'),
+        id: z.string(),
+        title: z.string(),
+        data: z
+          .record(z.string(), z.unknown())
+          .optional()
+          .describe(
+            'The values this opaque body DISPLAYS, in its own vocabulary — `transform` ' +
+              'carries {position, rotation, scale}, three numbers each, rotation in Euler ' +
+              'XYZ DEGREES exactly as the section’s inputs show it.',
+          ),
+      }),
+      z.object({ kind: z.literal('preview'), id: z.string(), title: z.string() }),
+    ])
+    .describe(
+      'A field list, or a NAMED OPAQUE for a section the editor renders with React — ' +
+        '`custom` for a contributed block, `preview` for the subject’s own live view.',
+    ),
+});
+
+const InspectedSubjectSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  kindLabel: z.string().optional(),
+  hint: z.string().optional().describe('The quiet line a subject with nothing to edit carries.'),
+  presentation: z.object({
+    preferred: z.string().describe('The surface’s presentation affinity: card|column.'),
+    resolved: z.string().optional().describe('The presentation actually showing.'),
+    surface: z.string().optional().describe('three|canvas|dom|asset-lab.'),
+  }),
+  quickActions: z.array(
+    z.object({
+      id: z.string(),
+      title: z.string(),
+      label: z.string().optional(),
+      pressed: z
+        .boolean()
+        .optional()
+        .describe('Toggle state — how the visibility eye reports visible/hidden.'),
+      disabled: z.boolean().optional(),
+    }),
+  ),
+  sections: z.array(InspectedSectionSchema),
+});
+
+/**
+ * NOTHING is being inspected — the inspector is unmounted, which since
+ * 2026-08-07 is what a human sees whenever nothing is selected on a surface
+ * with no empty-state subject of its own.
+ *
+ * An explicit token rather than `null`, because every "absent" value on this
+ * wire already means "nobody answered" and surfaces as
+ * `INSPECTION_UNAVAILABLE`. Reporting the two the same way is the only way an
+ * agent could mistake a working editor for a broken one.
+ */
+const NothingInspectedSchema = z
+  .object({ none: z.literal(true).describe('There is no inspector showing.') })
+  .describe('Nothing is being inspected.');
+
+const InspectionReadSchema = z.union([InspectedSubjectSchema, NothingInspectedSchema]);
+
+const EditorInspectionGetInput = z
+  .object({})
+  .describe('No input — reads whatever the target session’s inspector is showing right now.');
+
+export const editorInspectionGet = defineTool({
+  name: 'editor.inspection.get',
+  summary: 'Read the inspection subject the editor is showing, as data.',
+  description:
+    'The serialized projection of the inspection model — the same subject a human reads in the ' +
+    'inspector: identity, presentation, verbs, and every identified section in display order, ' +
+    'with a fields section carrying the CURRENT VALUE at each scriptable path. When the ' +
+    'inspector is showing nothing the answer is {none:true}; a surface whose empty space is a ' +
+    'real thing (an open Asset Lab document) reports THAT subject, never another surface’s. An ' +
+    'opaque section body is a named {kind,id,title}, plus `data` when the section can say what ' +
+    'it displays (transform: position/rotation/scale).',
+  input: EditorInspectionGetInput,
+  result: InspectionReadSchema,
+  errors: [EDITOR_NOT_RUNNING_ERROR, INSPECTION_UNAVAILABLE_ERROR],
+  requires: { editor: true },
+  host: 'editor-browser',
+  mutates: false,
+  supportsDryRun: false,
+  permission: { risk: 'read', summary: 'Reads live editor inspection state only.' },
+  async impl(_input, ctx) {
+    const transport = getTransport(ctx);
+    const session = await resolveEditorSession(ctx, transport);
+    const subject = await withTimeout(
+      transport.getInspection(session, EDITOR_COMMAND_TIMEOUT_MS),
+      EDITOR_COMMAND_TIMEOUT_MS,
+      'editor.inspection.get',
+    ).catch(() => undefined);
+    if (!subject) {
+      throw new ToolError(
+        'INSPECTION_UNAVAILABLE',
+        'The connected editor session did not answer the inspection read in time.',
+        {},
+      );
+    }
+    return subject;
+  },
+});
+
+export function registerEditorInspectionOperations(registry: ToolRegistry): void {
+  registry.register(editorInspectionGet);
+}

package/src/editor/open-operations.ts

@@ -49,51 +49,12 @@ const STORY_OPEN_UNSUPPORTED_ERROR = {
 const OkResult = z.object({ ok: z.literal(true) });
 
 // ---------------------------------------------------------------------------
-// editor.scene.open
+// WO-8: `editor.scene.open` lived here. It relayed `{type:'open-scene', path}` to
+// a connected editor, and that verb now REJECTS — there is no scene document to
+// open, because the `.vscn.json` format is deleted. A tool whose only relay is a
+// guaranteed rejection is worse than no tool.
 // ---------------------------------------------------------------------------
 
-const EditorSceneOpenInput = z.object({
-  path: z
-    .string()
-    .describe('Project-relative path to a .vscn.json scene file to open in the editor.'),
-});
-
-export const editorSceneOpen = defineTool({
-  name: 'editor.scene.open',
-  summary: 'Open a scene file in a connected editor session.',
-  description:
-    'Relays {type:"open-scene", path} through POST /__editor/command — an existing, already-handled case.',
-  input: EditorSceneOpenInput,
-  result: OkResult,
-  errors: [EDITOR_NOT_RUNNING_ERROR, COMMAND_FAILED_ERROR],
-  requires: { editor: true },
-  host: 'editor-browser',
-  mutates: true,
-  supportsDryRun: false,
-  permission: { risk: 'write', summary: 'Changes which scene the live editor has loaded.' },
-  async impl(input, ctx) {
-    const transport = getTransport(ctx);
-    const session = await resolveEditorSession(ctx, transport);
-    const result = await withTimeout(
-      transport.sendCommand(
-        session,
-        { type: 'open-scene', path: input.path },
-        EDITOR_COMMAND_TIMEOUT_MS,
-      ),
-      EDITOR_COMMAND_TIMEOUT_MS,
-      'editor.scene.open',
-    ).catch((err: unknown) => ({
-      ok: false,
-      error: err instanceof Error ? err.message : String(err),
-    }));
-    if (!result.ok) {
-      throw new ToolError('COMMAND_FAILED', result.error ?? 'open-scene command failed', {
-        message: result.error ?? 'open-scene command failed',
-      });
-    }
-    return { ok: true as const };
-  },
-});
 
 // ---------------------------------------------------------------------------
 // editor.asset.open
@@ -203,7 +164,6 @@ export const editorStoryOpen = defineTool({
 });
 
 export function registerOpenOperations(registry: ToolRegistry): void {
-  registry.register(editorSceneOpen);
   registry.register(editorAssetOpen);
   registry.register(editorStoryOpen);
 }

package/src/editor/transport.ts

@@ -1,6 +1,5 @@
 /**
- * Transport seam for B3's `editor.*` operations
- * (docs/AI-NATIVE-AUTHORING-IMPLEMENTATION-SPEC.md §8 B3).
+ * Transport seam for B3's `editor.*` operations.
  *
  * Every `editor.*` op needs two things this module provides:
  *
@@ -49,6 +48,12 @@
  *    silently acking (B3-followup's false-ack fix — see command-listener.ts)
  *    — this module never has to work around that fallthrough by avoiding a
  *    command send the way `openStory` below still does.
+ *  - Inspection read: `POST /__editor/command` `{type:'inspect'}` — a real,
+ *    handled case that serializes the LIVE inspection subject
+ *    (`packages/editor/src/inspection/active-subject.ts`), the same one the
+ *    inspector's column and compact card render. When those render nothing it
+ *    answers `{none:true}`; an ABSENT answer stays reserved for "no tab
+ *    replied", which is what `INSPECTION_UNAVAILABLE` reports.
  *  - Hierarchy inspect / viewport camera read (B3-followup, now genuinely
  *    wired): `collectState` (`packages/editor/src/command-listener.ts`) now
  *    reports the real flattened entity tree (`entities`, reusing
@@ -172,8 +177,6 @@ export interface EditorSessionInfo {
   project: string | null;
   /** Dev-server process id, when known from the local session registry (null for an unregistered/legacy server the caller only probed by port). */
   pid: number | null;
-  /** Registry discriminator. `kind: 'e2e'` is a standalone proof server, never an editor-control target. */
-  kind?: string;
   /** Exact explicitly targeted editor origin/base URL, including protocol and host. */
   url?: string;
 }
@@ -206,6 +209,68 @@ export interface HierarchySummary {
   entities: HierarchyNodeInfo[] | null;
 }
 
+/**
+ * The serialized inspection subject (`editor.inspection.get`) — the wire
+ * mirror of the editor's own `SerializedInspectionSubject`
+ * (`packages/editor/src/inspection/serialize.ts`, which owns the contract).
+ * `InspectionSubjectSchema` in `inspection-operations.ts` is the Zod half.
+ */
+export interface InspectedFieldInfo {
+  path: string;
+  label: string;
+  type: string;
+  value?: unknown;
+  mixed?: true;
+  defaulted?: boolean;
+  readonly?: boolean;
+  resettable?: boolean;
+  revertsTo?: string;
+  group?: string;
+  options?: unknown[];
+}
+
+export type InspectedSectionBodyInfo =
+  | { kind: 'fields'; fields: InspectedFieldInfo[] }
+  /** `data` is the section's own displayed values, in its own vocabulary,
+   *  when it has any (`transform`: `{position, rotation, scale}`). */
+  | { kind: 'custom'; id: string; title: string; data?: Record<string, unknown> }
+  | { kind: 'preview'; id: string; title: string };
+
+export interface InspectedSectionInfo {
+  id: string;
+  title: string;
+  order: number;
+  description?: string;
+  body: InspectedSectionBodyInfo;
+}
+
+export interface InspectedActionInfo {
+  id: string;
+  title: string;
+  label?: string;
+  pressed?: boolean;
+  disabled?: boolean;
+}
+
+export interface InspectedSubjectInfo {
+  id: string;
+  title: string;
+  kindLabel?: string;
+  hint?: string;
+  presentation: { preferred: string; resolved?: string; surface?: string };
+  quickActions: InspectedActionInfo[];
+  sections: InspectedSectionInfo[];
+}
+
+/** The editor answered, and the answer is that NOTHING is being inspected —
+ *  the box is unmounted. Distinct from an absent reply, which means nobody
+ *  answered and surfaces as `INSPECTION_UNAVAILABLE`. */
+export interface InspectedNothingInfo {
+  none: true;
+}
+
+export type InspectionReadInfo = InspectedSubjectInfo | InspectedNothingInfo;
+
 export interface CameraPose {
   position: { x: number; y: number; z: number };
   target: { x: number; y: number; z: number };
@@ -257,6 +322,13 @@ export interface EditorTransport {
     timeoutMs: number,
   ): Promise<HierarchySummary | undefined>;
   getCamera(session: EditorSessionInfo, timeoutMs: number): Promise<CameraPose | undefined>;
+  /** What the editor's inspector is showing — a subject, or the explicit
+   *  `{none:true}` when the box is unmounted. `undefined` means no browser tab
+   *  answered the relay, which is a different fact and a different error. */
+  getInspection(
+    session: EditorSessionInfo,
+    timeoutMs: number,
+  ): Promise<InspectionReadInfo | undefined>;
   setCamera(
     session: EditorSessionInfo,
     request: CameraSetRequest,
@@ -307,8 +379,7 @@ function isRegistrySessionEntry(v: unknown): v is RegistrySessionEntry {
     (typeof s['project'] === 'string' || s['project'] === null) &&
     typeof s['port'] === 'number' &&
     typeof s['pid'] === 'number' &&
-    typeof s['startedAt'] === 'string' &&
-    (s['kind'] === undefined || typeof s['kind'] === 'string')
+    typeof s['startedAt'] === 'string'
   );
 }
 
@@ -334,7 +405,6 @@ function readRegisteredSessions(): RegistrySessionEntry[] {
     return Array.isArray(raw)
       ? raw
           .filter(isRegistrySessionEntry)
-          .filter((s) => s.kind !== 'e2e')
           .filter((s) => pidAlive(s.pid))
       : [];
   } catch {
@@ -372,7 +442,7 @@ async function postJson(
 }
 
 function baseUrl(session: EditorSessionInfo): string {
-  return session.url ?? `http://localhost:${session.port}`;
+  return session.url ?? `http://127.0.0.1:${session.port}`;
 }
 
 /** The real, production transport — HTTP against a live `vgai edit` dev server. */
@@ -411,7 +481,6 @@ export class HttpEditorTransport implements EditorTransport {
           port: s.port,
           project,
           pid: s.pid,
-          ...(s.kind !== undefined ? { kind: s.kind } : {}),
         };
         return info;
       }),
@@ -463,6 +532,22 @@ export class HttpEditorTransport implements EditorTransport {
     return body?.camera;
   }
 
+  async getInspection(
+    session: EditorSessionInfo,
+    timeoutMs: number,
+  ): Promise<InspectionReadInfo | undefined> {
+    // A real, handled case in the browser's `handleCommand` switch
+    // (`packages/editor/src/command-listener.ts`, `case 'inspect'`), which
+    // composes the subject through the SAME composer both visual projections
+    // use. No browser tab attached -> `{ok:false}` -> undefined, which the
+    // operation reports as INSPECTION_UNAVAILABLE rather than an empty subject.
+    const result = await this.sendCommand(session, { type: 'inspect' }, timeoutMs).catch(
+      () => undefined,
+    );
+    const subject = result?.ok ? result.data?.['subject'] : undefined;
+    return subject && typeof subject === 'object' ? (subject as InspectionReadInfo) : undefined;
+  }
+
   async setCamera(
     session: EditorSessionInfo,
     request: CameraSetRequest,
@@ -681,7 +766,6 @@ export async function resolveEditorSession(
   } catch {
     return notRunning();
   }
-  sessions = sessions.filter((session) => session.kind !== 'e2e');
   if (sessions.length === 0) return notRunning();
 
   if (editorUrl !== undefined) {

package/src/operations.ts

@@ -18,9 +18,10 @@
  * implementation.
  */
 
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
 import { z } from 'zod';
+// Zod-only, no DOM — the same relative-path seam `create-vgai-project` and
+// `vgai-cli` already use to reach the manifest helpers.
+import { hasManifest } from '../../engine/src/manifest/load-file.js';
 import { ToolError } from './errors.js';
 import { defineTool, type ToolRegistry } from './registry.js';
 
@@ -37,7 +38,7 @@ export const ProjectStatusResult = z
     projectRoot: z.string().describe('Absolute path this status was computed for.'),
     hasProject: z
       .boolean()
-      .describe('True when a vgai.game.json manifest exists directly under projectRoot.'),
+      .describe('True when a vgai.project.json manifest exists directly under projectRoot.'),
   })
   .describe('Discovery result for the project at ctx.projectRoot.');
 
@@ -47,7 +48,7 @@ export const projectStatus = defineTool({
   description:
     'File-native discovery operation (B2 project.* namespace stand-in for B1). Reads ' +
     'ctx.projectRoot from disk — no editor process required — and reports whether a ' +
-    'vgai.game.json manifest is present there.',
+    'vgai.project.json manifest is present there.',
   input: ProjectStatusInput,
   result: ProjectStatusResult,
   errors: [
@@ -72,7 +73,11 @@ export const projectStatus = defineTool({
     }
     return {
       projectRoot: ctx.projectRoot,
-      hasProject: existsSync(join(ctx.projectRoot, 'vgai.game.json')),
+      // `hasManifest` OWNS the dual-name contract. Spelling the two filenames
+      // out here made this the fifth independent copy of it, and the one most
+      // likely to drift silently: it is the answer `project.status` gives
+      // through all four projections (SDK/CLI/HTTP/MCP).
+      hasProject: hasManifest(ctx.projectRoot),
     };
   },
 });

package/src/perf/perf-run.ts

@@ -47,8 +47,8 @@ export interface PerfFrameSample {
   };
 }
 
-/** Mirrors `@engine/runtime/render-control`'s `PerfWorldCount`. */
-export interface PerfWorldCount {
+/** Mirrors `@engine/runtime/render-control`'s `PerfRootCount`. */
+export interface PerfRootCount {
   readonly id: string;
   readonly kind: string;
   readonly nodes: number;
@@ -95,7 +95,7 @@ export interface PerfRunResult {
   readonly entryQuery: string | undefined;
   readonly excludedFromDeterminism: readonly string[];
   readonly frameSamples: readonly PerfFrameSample[];
-  readonly worlds: readonly PerfWorldCount[];
+  readonly worlds: readonly PerfRootCount[];
 }
 
 export class PerfRunError extends Error {}
@@ -208,7 +208,7 @@ export async function runPerfCapture(request: PerfRunRequest): Promise<PerfRunRe
           }
         ).__vgaiRender.perfSample(steps),
       frames,
-    )) as { frames: PerfFrameSample[]; worlds: PerfWorldCount[] };
+    )) as { frames: PerfFrameSample[]; worlds: PerfRootCount[] };
 
     const fixedDt = await page.evaluate(() =>
       (