@fps-games/editor 0.2.1-beta.3 → 0.2.1-beta.4

package/dist/{agent-bridge → editor-commands}/register.js

@@ -1,1128 +1,1165 @@
-import { EDITOR_AGENT_BRIDGE_CAPABILITY_ID, EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS, EDITOR_AGENT_BRIDGE_SCHEMA_VERSION, } from '@fps-games/editor-protocol';
-import { createLocalEditorAgentBridgeFailure } from './diagnostics.js';
+import { EDITOR_COMMAND_ID, EDITOR_COMMAND_BUILT_IN_TARGETS, EDITOR_COMMAND_SCHEMAS, EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION, } from '@fps-games/editor-protocol';
+import { registerEditorAuthoringHostCommandCapability } from '@fps-games/editor-core';
+import { createLocalEditorCommandFailure } from './diagnostics.js';
 // Static baked shadow authoring is intentionally hidden until the workflow is redesigned.
 const EDITOR_SHADOW_STATIC_AUTHORING_ENABLED = false;
-export function registerLocalEditorAgentBridgeCapabilities(bridge, sources) {
-    const registerCapability = (registration) => bridge.registerCapability({
-        ...registration,
-        handler: async (input, context) => {
-            if (registration.manifest.access === 'write' && sources.host.isBusy()) {
-                return createLocalEditorAgentBridgeFailure(registration.manifest.id, 'Host is busy and cannot accept editor mutations.', { code: 'host.busy' });
-            }
-            return registration.handler(input, context);
-        },
-    });
+const LOCAL_EDITOR_COMPOSED_AUTHORING_WRITE_IDS = new Set([
+    EDITOR_COMMAND_ID.HIERARCHY_OPERATION_EXECUTE,
+    EDITOR_COMMAND_ID.PREFAB_STAGE_OPEN,
+    EDITOR_COMMAND_ID.PREFAB_STAGE_EXIT,
+    EDITOR_COMMAND_ID.PREFAB_STAGE_SAVE,
+    EDITOR_COMMAND_ID.PREFAB_STAGE_DISCARD,
+    EDITOR_COMMAND_ID.PREFAB_ASSET_RENAME,
+    EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_FROM_ASSET,
+    EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_GROUP,
+    EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_MARKER,
+    EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_PRIMITIVE,
+    EDITOR_COMMAND_ID.PREFAB_NODE_SET_TRANSFORM,
+    EDITOR_COMMAND_ID.PREFAB_NODE_SET_MARKER,
+    EDITOR_COMMAND_ID.PREFAB_NODE_REPARENT,
+    EDITOR_COMMAND_ID.PREFAB_NODE_RENAME,
+    EDITOR_COMMAND_ID.PREFAB_NODE_DELETE,
+    EDITOR_COMMAND_ID.OBJECT_CREATE_PRIMITIVE,
+    EDITOR_COMMAND_ID.OBJECT_CREATE_FROM_ASSET,
+    EDITOR_COMMAND_ID.OBJECT_DELETE,
+    EDITOR_COMMAND_ID.SHADOW_POLICY_SET,
+    EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET,
+    EDITOR_COMMAND_ID.TRANSFORM_MOVE,
+    EDITOR_COMMAND_ID.TRANSFORM_SET,
+]);
+export function registerLocalEditorCommandCapabilities(adapter, sources, authoringHost) {
+    const registerCapability = (registration) => (authoringHost
+        && (LOCAL_EDITOR_COMPOSED_AUTHORING_WRITE_IDS.has(registration.manifest.id)
+            || EDITOR_COMMAND_BUILT_IN_TARGETS[registration.manifest.id] === 'authoring')
+        ? registerEditorAuthoringHostCommandCapability(authoringHost, {
+            ...registration,
+            handler: async (input, context) => {
+                if (registration.manifest.access === 'write' && sources.host.isBusy()) {
+                    return createLocalEditorCommandFailure(registration.manifest.id, 'Host is busy and cannot accept editor mutations.', { code: 'host.busy' });
+                }
+                return registration.handler(input, context);
+            },
+        })
+        : adapter.registerCapability({
+            ...registration,
+            handler: async (input, context) => {
+                if (registration.manifest.access === 'write' && sources.host.isBusy()) {
+                    return createLocalEditorCommandFailure(registration.manifest.id, 'Host is busy and cannot accept editor mutations.', { code: 'host.busy' });
+                }
+                return registration.handler(input, context);
+            },
+        }));
     const unregister = [
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HIERARCHY_SCOPE_GET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.HIERARCHY_SCOPE_GET,
                 title: 'Get active Hierarchy scope',
                 description: 'Read the active scoped Hierarchy snapshot, with backward-compatible full-tree output or revision-bound subtree, search, and cursor pagination queries.',
                 layer: 'editor', category: 'hierarchy', stability: 'experimental', access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HIERARCHY_SCOPE_GET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.HIERARCHY_SCOPE_GET],
             },
-            handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HIERARCHY_SCOPE_GET, input);
+            handler: (input, context) => {
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.HIERARCHY_SCOPE_GET, input);
                 return normalized.ok ? sources.hierarchy.getScope(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HIERARCHY_OPERATIONS_LIST,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.HIERARCHY_OPERATIONS_LIST,
                 title: 'List Hierarchy operations',
                 description: 'Discover the same scope-aware Hierarchy operations used by menus and keyboard commands.',
                 layer: 'editor', category: 'hierarchy', stability: 'experimental', access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HIERARCHY_OPERATIONS_LIST],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.HIERARCHY_OPERATIONS_LIST],
             },
-            handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HIERARCHY_OPERATIONS_LIST, input);
+            handler: (input, context) => {
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.HIERARCHY_OPERATIONS_LIST, input);
                 return normalized.ok ? sources.hierarchy.listOperations(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HIERARCHY_OPERATION_EXECUTE,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.HIERARCHY_OPERATION_EXECUTE,
                 title: 'Execute Hierarchy operation',
                 description: 'Execute a discovered Hierarchy operation against an exact scope revision using the same provider transaction as the editor UI.',
                 layer: 'editor', category: 'hierarchy', stability: 'experimental', access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HIERARCHY_OPERATION_EXECUTE],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.HIERARCHY_OPERATION_EXECUTE],
             },
-            handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HIERARCHY_OPERATION_EXECUTE, input);
-                return normalized.ok ? sources.hierarchy.executeOperation(normalized.input) : normalized.result;
+            handler: (input, context) => {
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.HIERARCHY_OPERATION_EXECUTE, input);
+                return normalized.ok ? sources.hierarchy.executeOperation(normalized.input, context) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.ASSET_LIBRARY_LIST,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.ASSET_LIBRARY_LIST,
                 title: 'List asset library',
                 description: 'List standard project assets after editorReady=true. Use this before placing assets; returned assetId values are stable inputs for asset.info.get, asset.analysis.get, and object.createFromAsset.',
                 layer: 'editor',
                 category: 'asset',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.ASSET_LIBRARY_LIST],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.ASSET_LIBRARY_LIST],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.ASSET_LIBRARY_LIST, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.ASSET_LIBRARY_LIST, input);
                 return normalized.ok ? sources.assets.listAssets(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.ASSET_INFO_GET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.ASSET_INFO_GET,
                 title: 'Get asset info',
                 description: 'Read complete serializable metadata for one standard project asset by assetId. It does not read original file bytes and should be used before placement when catalog metadata matters.',
                 layer: 'editor',
                 category: 'asset',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.ASSET_INFO_GET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.ASSET_INFO_GET],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.ASSET_INFO_GET, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.ASSET_INFO_GET, input);
                 return normalized.ok ? sources.assets.getAssetInfo(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.ASSET_ANALYSIS_GET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.ASSET_ANALYSIS_GET,
                 title: 'Get asset analysis',
                 description: 'Read SDK-generated raw asset structure analysis from asset metadata. Use for GLB/GLTF mesh/material complexity and PNG/JPEG/WebP image dimensions before creating or inspecting assets.',
                 layer: 'editor',
                 category: 'asset',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.ASSET_ANALYSIS_GET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.ASSET_ANALYSIS_GET],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.ASSET_ANALYSIS_GET, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.ASSET_ANALYSIS_GET, input);
                 return normalized.ok ? sources.assets.getAssetAnalysis(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_RESOLVE,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.PREFAB_RESOLVE,
                 title: 'Resolve prefab asset',
                 description: 'Resolve prefab assets by assetId, browserAssetId, exact name, or fuzzy query after editorReady=true. Use asset.library.list(kind=prefab) or this capability before prefab.stage.open.',
                 layer: 'editor',
                 category: 'prefab',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_RESOLVE],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.PREFAB_RESOLVE],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_RESOLVE, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.PREFAB_RESOLVE, input);
                 return normalized.ok ? sources.prefabs.resolvePrefab(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_OPEN,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.PREFAB_STAGE_OPEN,
                 title: 'Open prefab stage',
                 description: 'Enter the prefab preview/edit stage for a prefab asset after editorReady=true. Prefer this over double-clicking the Asset Library; it is idempotent when the requested prefab is already open.',
                 layer: 'editor',
                 category: 'prefab',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_OPEN],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.PREFAB_STAGE_OPEN],
             },
-            handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_OPEN, input);
-                return normalized.ok ? sources.prefabs.openStage(normalized.input) : normalized.result;
+            handler: (input, context) => {
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.PREFAB_STAGE_OPEN, input);
+                return normalized.ok ? sources.prefabs.openStage(normalized.input, context) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_EXIT,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.PREFAB_STAGE_EXIT,
                 title: 'Exit prefab stage',
                 description: 'Exit the current prefab preview/edit stage and return to the scene editor. This is idempotent and returns exited=false when no prefab stage is open.',
                 layer: 'editor',
                 category: 'prefab',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_EXIT],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.PREFAB_STAGE_EXIT],
             },
-            handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_EXIT, input);
-                return normalized.ok ? sources.prefabs.exitStage(normalized.input) : normalized.result;
+            handler: (input, context) => {
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.PREFAB_STAGE_EXIT, input);
+                return normalized.ok ? sources.prefabs.exitStage(normalized.input, context) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_SAVE,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.PREFAB_STAGE_SAVE,
                 title: 'Save prefab stage',
                 description: 'Persist the complete authoring document from the active Prefab draft and keep the Prefab stage open.',
                 layer: 'editor',
                 category: 'prefab',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_SAVE],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.PREFAB_STAGE_SAVE],
             },
-            handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_SAVE, input);
-                return normalized.ok ? sources.prefabs.saveStage(normalized.input) : normalized.result;
+            handler: (input, context) => {
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.PREFAB_STAGE_SAVE, input);
+                return normalized.ok ? sources.prefabs.saveStage(normalized.input, context) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_DISCARD,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.PREFAB_STAGE_DISCARD,
                 title: 'Discard prefab stage changes',
                 description: 'Reset the active Prefab draft to its entry or last-save checkpoint and keep the Prefab stage open.',
                 layer: 'editor',
                 category: 'prefab',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_DISCARD],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.PREFAB_STAGE_DISCARD],
             },
-            handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_STAGE_DISCARD, input);
-                return normalized.ok ? sources.prefabs.discardStage(normalized.input) : normalized.result;
+            handler: (input, context) => {
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.PREFAB_STAGE_DISCARD, input);
+                return normalized.ok ? sources.prefabs.discardStage(normalized.input, context) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_ASSET_RENAME,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.PREFAB_ASSET_RENAME,
                 title: 'Rename prefab asset',
                 description: 'Rename a prefab asset displayName through the editor asset action patch pipeline. In an open Prefab stage, assetId may be omitted to rename the current prefab; this does not rename existing scene prefab instances or readonly GLB source nodes.',
                 layer: 'editor',
                 category: 'prefab',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_ASSET_RENAME],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.PREFAB_ASSET_RENAME],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_ASSET_RENAME, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.PREFAB_ASSET_RENAME, input);
                 return normalized.ok ? sources.prefabs.renameAsset(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_SCENE_GET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.PREFAB_SCENE_GET,
                 title: 'Get prefab composition scene',
                 description: 'Read the editable Prefab Scene Tree for the currently open Prefab stage. Use after prefab.stage.open before prefab.node.* writes; this does not expose raw GLB source nodes as editable prefab nodes.',
                 layer: 'editor',
                 category: 'prefab',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_SCENE_GET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.PREFAB_SCENE_GET],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_SCENE_GET, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.PREFAB_SCENE_GET, input);
                 return normalized.ok ? sources.prefabs.getScene(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SELECT,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.PREFAB_NODE_SELECT,
                 title: 'Select prefab node',
                 description: 'Select an editable node inside the current Prefab stage. Use node ids from prefab.scene.get; this changes Prefab stage selection, not main scene selection.',
                 layer: 'editor',
                 category: 'prefab',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SELECT],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.PREFAB_NODE_SELECT],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SELECT, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.PREFAB_NODE_SELECT, input);
                 return normalized.ok ? sources.prefabs.selectNode(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_FROM_ASSET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_FROM_ASSET,
                 title: 'Create prefab node from asset',
                 description: 'Add a model or child prefab asset into the currently open Prefab stage through the editor asset action patch pipeline. Use asset.library.list first; this writes the prefab document, not the main scene.',
                 layer: 'editor',
                 category: 'prefab',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_FROM_ASSET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_FROM_ASSET],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_FROM_ASSET, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_FROM_ASSET, input);
                 return normalized.ok ? sources.prefabs.createNodeFromAsset(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_GROUP,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_GROUP,
                 title: 'Create prefab group node',
                 description: 'Add an empty group node to the currently open Prefab stage through the editor prefab node mutation path. Use it as a composition container before adding or reparenting model, primitive, or child prefab nodes.',
                 layer: 'editor',
                 category: 'prefab',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_GROUP],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_GROUP],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_GROUP, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_GROUP, input);
                 return normalized.ok ? sources.prefabs.createGroupNode(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_MARKER,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_MARKER,
                 title: 'Create prefab Marker node',
                 description: 'Add a transform-capable Marker node to the open Prefab stage. Type must come from the project Marker catalog and target may only reference the current Prefab composition.',
                 layer: 'editor',
                 category: 'prefab',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_MARKER],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_MARKER],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_MARKER, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_MARKER, input);
                 return normalized.ok ? sources.prefabs.createMarkerNode(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_PRIMITIVE,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_PRIMITIVE,
                 title: 'Create prefab primitive node',
                 description: 'Add a primitive helper node to the currently open Prefab stage through the editor prefab node mutation path. Use for composition layout tests, blockers, receivers, and simple placeholders.',
                 layer: 'editor',
                 category: 'prefab',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_PRIMITIVE],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_PRIMITIVE],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_CREATE_PRIMITIVE, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_PRIMITIVE, input);
                 return normalized.ok ? sources.prefabs.createPrimitiveNode(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_TRANSFORM,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.PREFAB_NODE_SET_TRANSFORM,
                 title: 'Set prefab node transform',
                 description: 'Set position, rotation, and/or scale for an editable Prefab stage node. This routes through prefab node document patches and does not mutate projection or runtime JSON directly.',
                 layer: 'editor',
                 category: 'prefab',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_TRANSFORM],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.PREFAB_NODE_SET_TRANSFORM],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_TRANSFORM, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.PREFAB_NODE_SET_TRANSFORM, input);
                 return normalized.ok ? sources.prefabs.setNodeTransform(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_MARKER,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.PREFAB_NODE_SET_MARKER,
                 title: 'Set prefab Marker fields',
                 description: 'Update controlled Prefab Marker type, local target, tags, note, or RGB color. Geometry and semantic kind remain derived from the selected Marker type.',
                 layer: 'editor',
                 category: 'prefab',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_MARKER],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.PREFAB_NODE_SET_MARKER],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_SET_MARKER, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.PREFAB_NODE_SET_MARKER, input);
                 return normalized.ok ? sources.prefabs.setNodeMarker(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_REPARENT,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.PREFAB_NODE_REPARENT,
                 title: 'Reparent prefab node',
                 description: 'Move an editable Prefab stage node under another prefab node. The reducer rejects root reparenting and cyclic parents.',
                 layer: 'editor',
                 category: 'prefab',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_REPARENT],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.PREFAB_NODE_REPARENT],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_REPARENT, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.PREFAB_NODE_REPARENT, input);
                 return normalized.ok ? sources.prefabs.reparentNode(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_RENAME,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.PREFAB_NODE_RENAME,
                 title: 'Rename prefab node',
                 description: 'Rename a non-root editable node inside the current Prefab stage. Root names follow prefab.asset.rename, and readonly GLB Source Structure names are not editable.',
                 layer: 'editor',
                 category: 'prefab',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_RENAME],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.PREFAB_NODE_RENAME],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_RENAME, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.PREFAB_NODE_RENAME, input);
                 return normalized.ok ? sources.prefabs.renameNode(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_DELETE,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.PREFAB_NODE_DELETE,
                 title: 'Delete prefab node',
                 description: 'Delete an editable node from the current Prefab stage through prefab document mutation. Root deletion and invalid nodes return structured diagnostics.',
                 layer: 'editor',
                 category: 'prefab',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_DELETE],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.PREFAB_NODE_DELETE],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_NODE_DELETE, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.PREFAB_NODE_DELETE, input);
                 return normalized.ok ? sources.prefabs.deleteNode(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_SOURCE_STRUCTURE_GET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.PREFAB_SOURCE_STRUCTURE_GET,
                 title: 'Get prefab source structure',
                 description: 'Read readonly source asset anatomy for a prefab model node or asset. This reports SDK asset analysis metadata and is not an editable Prefab Scene Tree.',
                 layer: 'editor',
                 category: 'prefab',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_SOURCE_STRUCTURE_GET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.PREFAB_SOURCE_STRUCTURE_GET],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_SOURCE_STRUCTURE_GET, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.PREFAB_SOURCE_STRUCTURE_GET, input);
                 return normalized.ok ? sources.prefabs.getSourceStructure(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_MATERIAL_SLOTS_LIST,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.PREFAB_MATERIAL_SLOTS_LIST,
                 title: 'List prefab material slots',
                 description: 'List editable material override targets for a prefab model node or asset from SDK materialSlots metadata. Use before future material/shadow tuning; read-only slots are optional.',
                 layer: 'editor',
                 category: 'prefab',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_MATERIAL_SLOTS_LIST],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.PREFAB_MATERIAL_SLOTS_LIST],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.PREFAB_MATERIAL_SLOTS_LIST, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.PREFAB_MATERIAL_SLOTS_LIST, input);
                 return normalized.ok ? sources.prefabs.listMaterialSlots(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_MODE_GET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.HOST_MODE_GET,
                 title: 'Get host mode',
                 description: 'Read host lifecycle state without changing mode. Use as optional preflight or diagnostics; editorReady=true means the host is in editor mode, has an active editor session, and is not busy.',
                 layer: 'host',
                 category: 'lifecycle',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_MODE_GET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.HOST_MODE_GET],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_MODE_GET, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.HOST_MODE_GET, input);
                 return normalized.ok ? sources.host.getMode(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_EDITOR_ENTER,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.HOST_EDITOR_ENTER,
                 title: 'Enter editor mode',
                 description: 'Default L1 entry point for agents. Call this to enter or ensure editor mode before L2/L3 editor operations instead of clicking the UI with browser automation. It is idempotent: already-editor hosts return alreadyEditor=true.',
                 layer: 'host',
                 category: 'lifecycle',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_EDITOR_ENTER],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.HOST_EDITOR_ENTER],
             },
             handler: (input, context) => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_EDITOR_ENTER, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.HOST_EDITOR_ENTER, input);
                 return normalized.ok ? sources.host.enterEditor(normalized.input, context) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_EDITOR_SAVE_AND_RUN,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.HOST_EDITOR_SAVE_AND_RUN,
                 title: 'Save editor document and run game',
                 description: 'Run the product save lifecycle through the existing authoring persistence path, then leave editor mode and restart the game. Use only when a positive save lifecycle test is intended.',
                 layer: 'host',
                 category: 'lifecycle',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_EDITOR_SAVE_AND_RUN],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.HOST_EDITOR_SAVE_AND_RUN],
             },
             handler: (input, context) => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_EDITOR_SAVE_AND_RUN, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.HOST_EDITOR_SAVE_AND_RUN, input);
                 return normalized.ok ? sources.host.saveAndRun(normalized.input, context) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_EDITOR_DISCARD_AND_RUN,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.HOST_EDITOR_DISCARD_AND_RUN,
                 title: 'Discard editor changes and run game',
                 description: 'Leave editor mode without saving the working document and restart the game. Use after temporary editor experiments to restore the persisted project state.',
                 layer: 'host',
                 category: 'lifecycle',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_EDITOR_DISCARD_AND_RUN],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.HOST_EDITOR_DISCARD_AND_RUN],
             },
             handler: (input, context) => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_EDITOR_DISCARD_AND_RUN, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.HOST_EDITOR_DISCARD_AND_RUN, input);
                 return normalized.ok ? sources.host.discardAndRun(normalized.input, context) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_EDITOR_WAIT_READY,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.HOST_EDITOR_WAIT_READY,
                 title: 'Wait for editor readiness',
                 description: 'Read-only readiness wait. Use after host.editor.enter only when extra confirmation or timeout diagnostics are needed; it does not enter editor mode by itself.',
                 layer: 'host',
                 category: 'lifecycle',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_EDITOR_WAIT_READY],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.HOST_EDITOR_WAIT_READY],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.HOST_EDITOR_WAIT_READY, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.HOST_EDITOR_WAIT_READY, input);
                 return normalized.ok ? sources.host.waitReady(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.EDITOR_UI_REGIONS_GET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.EDITOR_UI_REGIONS_GET,
                 title: 'Get editor workspace regions',
-                description: 'Read the editor workspace region map for agents. It explains left Hierarchy, center Preview, right Inspector/render tabs, bottom Asset Library, top Toolbar, and Agent Bridge Console semantics, and maps each area to preferred capabilities before L0 fallback.',
+                description: 'Read the editor workspace region map for agents. It explains left Hierarchy, center Preview, right Inspector/render tabs, bottom Asset Library, top Toolbar, and Command Service Console semantics, and maps each area to preferred capabilities before L0 fallback.',
                 layer: 'editor',
                 category: 'ui',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.EDITOR_UI_REGIONS_GET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.EDITOR_UI_REGIONS_GET],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.EDITOR_UI_REGIONS_GET, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.EDITOR_UI_REGIONS_GET, input);
                 return normalized.ok ? sources.ui.getRegions(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SCENE_OBJECTS_LIST,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.SCENE_OBJECTS_LIST,
                 title: 'List scene objects',
                 description: 'List editor scene objects with hierarchy and transform summaries after editorReady=true. Use returned object ids as stable inputs for selection, transform, viewport, and workflow capabilities.',
                 layer: 'editor',
                 category: 'scene',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SCENE_OBJECTS_LIST],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.SCENE_OBJECTS_LIST],
             },
             handler: input => ({ objects: sources.objects.listObjects(input ?? {}) }),
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_RESOLVE,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.OBJECT_RESOLVE,
                 title: 'Resolve scene object',
                 description: 'Resolve editor scene objects by id, exact name/path/type, or fuzzy query after editorReady=true. Use this before write operations when the object id is not already known.',
                 layer: 'editor',
                 category: 'scene',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_RESOLVE],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.OBJECT_RESOLVE],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_RESOLVE, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.OBJECT_RESOLVE, input);
                 return normalized.ok ? sources.objects.resolveObject(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_CREATE_PRIMITIVE,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.OBJECT_CREATE_PRIMITIVE,
                 title: 'Create primitive object',
                 description: 'Create a basic scene primitive after editorReady=true. Shapes are cube, sphere, plane, or capsule; the capability uses the editor scene graph create patch and selects the created object when possible.',
                 layer: 'editor',
                 category: 'scene',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_CREATE_PRIMITIVE],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.OBJECT_CREATE_PRIMITIVE],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_CREATE_PRIMITIVE, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.OBJECT_CREATE_PRIMITIVE, input);
                 return normalized.ok ? sources.objects.createPrimitive(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_CREATE_FROM_ASSET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.OBJECT_CREATE_FROM_ASSET,
                 title: 'Create object from asset',
                 description: 'Create a scene object from a standard asset library asset after editorReady=true. Use asset.library.list and asset.analysis.get first; this capability delegates to the editor harness asset creation path and may select/focus the created object.',
                 layer: 'editor',
                 category: 'asset',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_CREATE_FROM_ASSET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.OBJECT_CREATE_FROM_ASSET],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_CREATE_FROM_ASSET, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.OBJECT_CREATE_FROM_ASSET, input);
                 return normalized.ok ? sources.objects.createFromAsset(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_DELETE,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.OBJECT_DELETE,
                 title: 'Delete objects',
                 description: 'Delete one or more editor scene objects after editorReady=true. Provide exactly one of objectId or objectIds; protected, locked, readonly, or missing nodes are rejected by scene graph validation.',
                 layer: 'editor',
                 category: 'scene',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_DELETE],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.OBJECT_DELETE],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.OBJECT_DELETE, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.OBJECT_DELETE, input);
                 return normalized.ok ? sources.objects.deleteObjects(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SELECTION_SET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.SELECTION_SET,
                 title: 'Set selection',
                 description: 'Select one or more editor scene objects by object id after editorReady=true. Prefer ids returned by scene.objects.list; this is an editor semantic operation, not a UI click.',
                 layer: 'editor',
                 category: 'selection',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SELECTION_SET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.SELECTION_SET],
             },
             handler: input => sources.selection.setSelection(input ?? {}),
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_POLICY_GET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.SHADOW_POLICY_GET,
                 title: 'Get shadow policy',
                 description: 'Read Shadow V2 policy and effective resolved plan for a scene object or current Prefab stage node. Use this before editing caster/receiver/light/quality settings; readonly source anatomy is not editable.',
                 layer: 'editor',
                 category: 'shadow',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_POLICY_GET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.SHADOW_POLICY_GET],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_POLICY_GET, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.SHADOW_POLICY_GET, input);
                 return normalized.ok ? sources.shadows.getPolicy(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_POLICY_SET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.SHADOW_POLICY_SET,
                 title: 'Set shadow policy',
                 description: 'Write Shadow V2 caster/receiver/mode/light/quality/params for a scene object or editable Prefab stage root/node through editor document patches. This is the default agent path for shadow authoring instead of Inspector clicking.',
                 layer: 'editor',
                 category: 'shadow',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_POLICY_SET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.SHADOW_POLICY_SET],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_POLICY_SET, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.SHADOW_POLICY_SET, input);
                 return normalized.ok ? sources.shadows.setPolicy(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_CONFIG_GET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_CONFIG_GET,
                 title: 'Get Shadow Map configuration',
                 description: 'Read the authoritative shadows.json configuration and available quality/behavior profile ids. The configuration is readonly; tune algorithm parameters in shadows.json, not through scene mutations.',
                 layer: 'editor',
                 category: 'shadow',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_CONFIG_GET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_CONFIG_GET],
             },
             handler: input => sources.shadows.getShadowMapExperimentConfig(input ?? {}),
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_POLICY_GET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_POLICY_GET,
                 title: 'Get Shadow Map profiles',
                 description: 'Read authored and effective Shadow Map quality/behavior profile references for the scene, a scene object, or an editable Prefab stage node.',
                 layer: 'editor',
                 category: 'shadow',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_POLICY_GET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_POLICY_GET],
             },
             handler: input => sources.shadows.getShadowMapExperimentPolicy(input),
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET,
                 title: 'Set Shadow Map profiles',
                 description: 'Write profile references only. Scene scope may set quality and behavior profiles; scene objects and Prefab nodes may set only a behavior profile. Inline algorithm or lifecycle parameters are not accepted.',
                 layer: 'editor',
                 category: 'shadow',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_POLICY_SET],
             },
             handler: input => sources.shadows.setShadowMapExperimentPolicy(input),
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_PLAN_PREVIEW,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_PLAN_PREVIEW,
                 title: 'Preview Shadow Map runtime plan',
                 description: 'Read the compiled Shadow Map Runtime Plan consumed by the renderer. This capability is readonly and exposes no authoring shortcut around shadows.json profiles.',
                 layer: 'editor',
                 category: 'shadow',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_PLAN_PREVIEW],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_PLAN_PREVIEW],
             },
             handler: input => sources.shadows.previewShadowMapExperimentPlan(input ?? {}),
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_RUNTIME_SNAPSHOT,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_RUNTIME_SNAPSHOT,
                 title: 'Snapshot Shadow Map runtime ownership',
                 description: 'Read Plan version, runtime registrations, activity owners, registry/depth evidence, and diagnostics without exposing a write path.',
                 layer: 'editor',
                 category: 'shadow',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_MAP_EXPERIMENT_RUNTIME_SNAPSHOT],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.SHADOW_MAP_EXPERIMENT_RUNTIME_SNAPSHOT],
             },
             handler: input => sources.shadows.snapshotShadowMapExperimentRuntime(input ?? {}),
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_RECEIVERS_LIST,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.SHADOW_RECEIVERS_LIST,
                 title: 'List shadow receivers',
                 description: 'List candidate shadow receiver nodes for a scene object or Prefab stage preview target. Explicit receivers and shadow.receive settings score above auto plane inference.',
                 layer: 'editor',
                 category: 'shadow',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_RECEIVERS_LIST],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.SHADOW_RECEIVERS_LIST],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_RECEIVERS_LIST, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.SHADOW_RECEIVERS_LIST, input);
                 return normalized.ok ? sources.shadows.listReceivers(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_RESOLVE_PREVIEW,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.SHADOW_RESOLVE_PREVIEW,
                 title: 'Resolve shadow preview',
                 description: 'Preview the resolved Shadow V2 backend, receiver list, light binding, quality params, and diagnostics without changing editor state. Use after policy changes or before screenshot validation.',
                 layer: 'editor',
                 category: 'shadow',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_RESOLVE_PREVIEW],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.SHADOW_RESOLVE_PREVIEW],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_RESOLVE_PREVIEW, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.SHADOW_RESOLVE_PREVIEW, input);
                 return normalized.ok ? sources.shadows.resolvePreview(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_INSPECT,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.SHADOW_DEBUG_INSPECT,
                 title: 'Inspect shadow debug context',
                 description: 'Read the complete Shadow V2 debugging context for a scene object or Prefab stage target: caster, receivers, light, policy, resolved plan, expected footprint, runtime evidence, and diagnostics. Use this before deciding whether a screenshot really shows a shadow.',
                 layer: 'editor',
                 category: 'shadow',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_INSPECT],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.SHADOW_DEBUG_INSPECT],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_INSPECT, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.SHADOW_DEBUG_INSPECT, input);
                 return normalized.ok ? sources.shadows.inspectDebug(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_CONTEXT_ENTER,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.SHADOW_DEBUG_CONTEXT_ENTER,
                 title: 'Enter shadow debug context',
                 description: 'Enter a preview-only Shadow Debug Context for a scene object or Prefab stage target. It automatically keeps the caster, resolved receivers, shadow light, and ambient lights visible, hides unrelated projected objects, applies receiver/footprint/light overlays, and returns inspect plus visibilityMeasure evidence for screenshot validation.',
                 layer: 'editor',
                 category: 'shadow',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_CONTEXT_ENTER],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.SHADOW_DEBUG_CONTEXT_ENTER],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_CONTEXT_ENTER, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.SHADOW_DEBUG_CONTEXT_ENTER, input);
                 return normalized.ok ? sources.shadows.enterDebugContext(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_CONTEXT_CLEAR,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.SHADOW_DEBUG_CONTEXT_CLEAR,
                 title: 'Clear shadow debug context',
                 description: 'Clear the preview-only Shadow Debug Context, including protected receiver visibility state and shadow debug overlays. This does not write scene or prefab documents.',
                 layer: 'editor',
                 category: 'shadow',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_CONTEXT_CLEAR],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.SHADOW_DEBUG_CONTEXT_CLEAR],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_CONTEXT_CLEAR, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.SHADOW_DEBUG_CONTEXT_CLEAR, input);
                 return normalized.ok ? sources.shadows.clearDebugContext(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_OVERLAY_SET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.SHADOW_DEBUG_OVERLAY_SET,
                 title: 'Set shadow debug overlay',
                 description: 'Show preview-only Shadow V2 debug helpers for a scene object or Prefab stage target: caster bounds, receiver bounds, light direction, expected footprint, and artifact bounds. This does not write scene or prefab documents; use before L0 screenshots to avoid visual misjudgment.',
                 layer: 'editor',
                 category: 'shadow',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_OVERLAY_SET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.SHADOW_DEBUG_OVERLAY_SET],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_OVERLAY_SET, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.SHADOW_DEBUG_OVERLAY_SET, input);
                 return normalized.ok ? sources.shadows.setDebugOverlay(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_OVERLAY_CLEAR,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.SHADOW_DEBUG_OVERLAY_CLEAR,
                 title: 'Clear shadow debug overlay',
                 description: 'Clear preview-only Shadow V2 debug helpers previously created by shadow.debug.overlay.set. This does not write scene or prefab documents.',
                 layer: 'editor',
                 category: 'shadow',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_OVERLAY_CLEAR],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.SHADOW_DEBUG_OVERLAY_CLEAR],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_OVERLAY_CLEAR, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.SHADOW_DEBUG_OVERLAY_CLEAR, input);
                 return normalized.ok ? sources.shadows.clearDebugOverlay(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_VISIBILITY_MEASURE,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.SHADOW_DEBUG_VISIBILITY_MEASURE,
                 title: 'Measure shadow visibility',
                 description: 'Return a structured Shadow V2 visibility score for a scene object or Prefab stage target. Use after shadow.debug.inspect or shadow.debug.overlay.set to avoid judging shadow success by screenshot alone. MVP measurement is structural when pixel readback is unavailable.',
                 layer: 'editor',
                 category: 'shadow',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_VISIBILITY_MEASURE],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.SHADOW_DEBUG_VISIBILITY_MEASURE],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_DEBUG_VISIBILITY_MEASURE, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.SHADOW_DEBUG_VISIBILITY_MEASURE, input);
                 return normalized.ok ? sources.shadows.measureVisibility(normalized.input) : normalized.result;
             },
         }),
         ...(EDITOR_SHADOW_STATIC_AUTHORING_ENABLED ? [
             registerCapability({
                 manifest: {
-                    schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                    id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_STATIC_BAKE,
+                    schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                    id: EDITOR_COMMAND_ID.SHADOW_STATIC_BAKE,
                     title: 'Bake static shadow',
                     description: 'Request a static shadow bake for the resolved Shadow V2 scene target through the editor rendering action pipeline. Use after shadow.resolvePreview confirms a static plan and receivers; prefab stage policies bake after placement in a scene.',
                     layer: 'editor',
                     category: 'shadow',
                     stability: 'experimental',
                     access: 'write',
-                    ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_STATIC_BAKE],
+                    ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.SHADOW_STATIC_BAKE],
                 },
                 handler: input => {
-                    const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_STATIC_BAKE, input);
+                    const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.SHADOW_STATIC_BAKE, input);
                     return normalized.ok ? sources.shadows.bakeStatic(normalized.input) : normalized.result;
                 },
             }),
             registerCapability({
                 manifest: {
-                    schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                    id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_STATIC_INVALIDATE,
+                    schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                    id: EDITOR_COMMAND_ID.SHADOW_STATIC_INVALIDATE,
                     title: 'Invalidate static shadow',
                     description: 'Mark a static Shadow V2 scene target as stale so agents and users know a rebake is required after transform, receiver, light, or policy changes.',
                     layer: 'editor',
                     category: 'shadow',
                     stability: 'experimental',
                     access: 'write',
-                    ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_STATIC_INVALIDATE],
+                    ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.SHADOW_STATIC_INVALIDATE],
                 },
                 handler: input => {
-                    const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.SHADOW_STATIC_INVALIDATE, input);
+                    const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.SHADOW_STATIC_INVALIDATE, input);
                     return normalized.ok ? sources.shadows.invalidateStatic(normalized.input) : normalized.result;
                 },
             }),
         ] : []),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.TRANSFORM_MOVE,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.TRANSFORM_MOVE,
                 title: 'Move object',
                 description: 'Move a scene object by absolute position or relative offset after editorReady=true. Provide exactly one of position or offset; the capability uses the editor document adapter path and returns before/after transform state.',
                 layer: 'editor',
                 category: 'transform',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.TRANSFORM_MOVE],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.TRANSFORM_MOVE],
             },
             handler: input => sources.transform.move(input),
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.TRANSFORM_SET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.TRANSFORM_SET,
                 title: 'Set object transform',
                 description: 'Set one or more absolute TRS fields on an editor scene object after editorReady=true. Provide objectId and at least one of position, rotation, or scale; the capability uses the editor document adapter path and returns before/after transform state.',
                 layer: 'editor',
                 category: 'transform',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.TRANSFORM_SET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.TRANSFORM_SET],
             },
             handler: input => sources.transform.set(input),
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_FOCUS_OBJECT,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.VIEWPORT_FOCUS_OBJECT,
                 title: 'Focus object in viewport',
                 description: 'Frame a scene object in the editor viewport after editorReady=true. Use this for semantic viewport focus instead of browser scrolling, dragging, or clicking the canvas.',
                 layer: 'editor',
                 category: 'viewport',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_FOCUS_OBJECT],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.VIEWPORT_FOCUS_OBJECT],
             },
             handler: input => sources.viewport.focusObject(input),
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_FRAME_SELECTION,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.VIEWPORT_FRAME_SELECTION,
                 title: 'Frame selected object',
                 description: 'Frame the current editor selection in the viewport after editorReady=true. Use after selection.set or transform operations when the active object is already selected.',
                 layer: 'editor',
                 category: 'viewport',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_FRAME_SELECTION],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.VIEWPORT_FRAME_SELECTION],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_FRAME_SELECTION, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.VIEWPORT_FRAME_SELECTION, input);
                 return normalized.ok ? sources.viewport.frameSelection(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_VISIBILITY_SNAPSHOT,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.VIEWPORT_VISIBILITY_SNAPSHOT,
                 title: 'Get preview visibility overrides',
                 description: 'Read preview-only visibility and isolation overrides. Use during visual debugging to understand what the editor viewport is temporarily hiding; this never reads or writes scene/prefab authored visibility.',
                 layer: 'editor',
                 category: 'viewport',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_VISIBILITY_SNAPSHOT],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.VIEWPORT_VISIBILITY_SNAPSHOT],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_VISIBILITY_SNAPSHOT, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.VIEWPORT_VISIBILITY_SNAPSHOT, input);
                 return normalized.ok ? sources.viewport.getVisibilitySnapshot(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_VISIBILITY_SET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.VIEWPORT_VISIBILITY_SET,
                 title: 'Set preview visibility',
                 description: 'Temporarily hide or show projected objects in the editor viewport for debugging. This is preview-only: it does not change scene object active/visible fields or prefab documents, and authored inactive objects are not revived.',
                 layer: 'editor',
                 category: 'viewport',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_VISIBILITY_SET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.VIEWPORT_VISIBILITY_SET],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_VISIBILITY_SET, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.VIEWPORT_VISIBILITY_SET, input);
                 return normalized.ok ? sources.viewport.setVisibility(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_VISIBILITY_CLEAR,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.VIEWPORT_VISIBILITY_CLEAR,
                 title: 'Clear preview visibility overrides',
                 description: 'Clear all preview-only visibility and isolation overrides, restoring the viewport to authored active/visible state without writing scene or prefab data.',
                 layer: 'editor',
                 category: 'viewport',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_VISIBILITY_CLEAR],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.VIEWPORT_VISIBILITY_CLEAR],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_VISIBILITY_CLEAR, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.VIEWPORT_VISIBILITY_CLEAR, input);
                 return normalized.ok ? sources.viewport.clearVisibility(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_ISOLATION_ENTER,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.VIEWPORT_ISOLATION_ENTER,
                 title: 'Enter preview isolation',
                 description: 'Temporarily isolate projected objects in the editor viewport by hiding unrelated objects. Use this before shadow screenshots to remove visual clutter; this is preview-only and never writes scene or prefab data.',
                 layer: 'editor',
                 category: 'viewport',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_ISOLATION_ENTER],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.VIEWPORT_ISOLATION_ENTER],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_ISOLATION_ENTER, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.VIEWPORT_ISOLATION_ENTER, input);
                 return normalized.ok ? sources.viewport.enterIsolation(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_CAMERA_GET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.VIEWPORT_CAMERA_GET,
                 title: 'Get viewport camera state',
                 description: 'Read the editor viewport camera state after editorReady=true. Use this to inspect the current view preset, projection, target, pose, radius, and selection before visual analysis.',
                 layer: 'editor',
                 category: 'viewport',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_CAMERA_GET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.VIEWPORT_CAMERA_GET],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_CAMERA_GET, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.VIEWPORT_CAMERA_GET, input);
                 return normalized.ok ? sources.viewport.getCamera(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_CAMERA_SET_PRESET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.VIEWPORT_CAMERA_SET_PRESET,
                 title: 'Set viewport camera preset',
                 description: 'Set a stable editor viewport camera preset after editorReady=true. Prefer top/front/side/iso/threeQuarterTop presets for agent visual analysis before falling back to browser screenshots.',
                 layer: 'editor',
                 category: 'viewport',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_CAMERA_SET_PRESET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.VIEWPORT_CAMERA_SET_PRESET],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_CAMERA_SET_PRESET, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.VIEWPORT_CAMERA_SET_PRESET, input);
                 return normalized.ok ? sources.viewport.setCameraPreset(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_CAMERA_ORBIT,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.VIEWPORT_CAMERA_ORBIT,
                 title: 'Orbit viewport camera',
                 description: 'Apply a semantic yaw/pitch/distance adjustment to the editor viewport camera after editorReady=true. Use for small inspection adjustments after a preset establishes the baseline view.',
                 layer: 'editor',
                 category: 'viewport',
                 stability: 'experimental',
                 access: 'write',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_CAMERA_ORBIT],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.VIEWPORT_CAMERA_ORBIT],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.VIEWPORT_CAMERA_ORBIT, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.VIEWPORT_CAMERA_ORBIT, input);
                 return normalized.ok ? sources.viewport.orbitCamera(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.EDITOR_SNAPSHOT_GET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.EDITOR_SNAPSHOT_GET,
                 title: 'Get editor snapshot',
                 description: 'Read a lightweight editor summary after editorReady=true. By default it returns mode, busy/dirty/status, selection, and objectCount; request includeObjects with objectLimit only when object summaries are needed.',
                 layer: 'editor',
                 category: 'state',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.EDITOR_SNAPSHOT_GET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.EDITOR_SNAPSHOT_GET],
             },
             handler: input => {
-                const normalized = normalizeObjectInput(EDITOR_AGENT_BRIDGE_CAPABILITY_ID.EDITOR_SNAPSHOT_GET, input);
+                const normalized = normalizeObjectInput(EDITOR_COMMAND_ID.EDITOR_SNAPSHOT_GET, input);
                 return normalized.ok ? sources.state.getSnapshot(normalized.input) : normalized.result;
             },
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.EDITOR_STATE_GET,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.EDITOR_STATE_GET,
                 title: 'Get editor state',
                 description: 'Read editor mode, status, selection, dirty state, and optional object summary. Use for verification after L1/L2 operations and for diagnostics before falling back to browser automation.',
                 layer: 'editor',
                 category: 'state',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.EDITOR_STATE_GET],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.EDITOR_STATE_GET],
             },
             handler: input => sources.state.getState(input ?? {}),
         }),
         registerCapability({
             manifest: {
-                schemaVersion: EDITOR_AGENT_BRIDGE_SCHEMA_VERSION,
-                id: EDITOR_AGENT_BRIDGE_CAPABILITY_ID.EDITOR_DIAGNOSTICS_LIST,
+                schemaVersion: EDITOR_COMMAND_CONTRACT_SCHEMA_VERSION,
+                id: EDITOR_COMMAND_ID.EDITOR_DIAGNOSTICS_LIST,
                 title: 'List editor diagnostics',
                 description: 'Read the same revision-aware diagnostics shown in the top-toolbar Validation Center, optionally filtered by severity, phase, or source.',
                 layer: 'editor',
                 category: 'state',
                 stability: 'experimental',
                 access: 'read',
-                ...EDITOR_AGENT_BRIDGE_CAPABILITY_SCHEMAS[EDITOR_AGENT_BRIDGE_CAPABILITY_ID.EDITOR_DIAGNOSTICS_LIST],
+                ...EDITOR_COMMAND_SCHEMAS[EDITOR_COMMAND_ID.EDITOR_DIAGNOSTICS_LIST],
             },
             handler: input => sources.state.listDiagnostics(input ?? {}),
         }),
@@ -1139,7 +1176,7 @@ function normalizeObjectInput(capabilityId, input) {
         return { ok: true, input: input };
     return {
         ok: false,
-        result: createLocalEditorAgentBridgeFailure(capabilityId, `${capabilityId} input must be an object.`, { code: 'host.invalidInput' }),
+        result: createLocalEditorCommandFailure(capabilityId, `${capabilityId} input must be an object.`, { code: 'host.invalidInput' }),
     };
 }
 //# sourceMappingURL=register.js.map