@vgai/sdk 0.5.0 → 0.5.2

package/src/project/asset-operations.ts

@@ -11,8 +11,8 @@
 import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from 'node:fs';
 import { dirname, extname, join, relative } from 'node:path';
 import { z } from 'zod';
-import { OperationError } from '../errors.js';
-import { defineOperation, type OperationRegistry } from '../registry.js';
+import { ToolError } from '../errors.js';
+import { defineTool, type ToolRegistry } from '../registry.js';
 import {
   DryRunField,
   mutationResultSchema,
@@ -49,7 +49,7 @@ const AssetEntrySchema = z.object({
   ext: z.string().describe('Lowercased file extension including the leading dot, or "" if none.'),
 });
 
-export const projectAssetList = defineOperation({
+export const projectAssetList = defineTool({
   name: 'project.asset.list',
   summary: 'List every file under the project’s public/ asset root (or a subdirectory of it).',
   description:
@@ -99,7 +99,7 @@ const ProjectAssetInspectInput = z.object({
   assetPath: z.string().describe('public/-relative path to inspect.'),
 });
 
-export const projectAssetInspect = defineOperation({
+export const projectAssetInspect = defineTool({
   name: 'project.asset.inspect',
   summary:
     'Inspect one asset under public/ — existence, size, mtime, and a content hash for small files.',
@@ -174,7 +174,7 @@ const ProjectAssetImportInput = z.object({
   dryRun: DryRunField,
 });
 
-export const projectAssetImport = defineOperation({
+export const projectAssetImport = defineTool({
   name: 'project.asset.import',
   summary: 'Copy an external file into the project’s public/ asset root.',
   description:
@@ -203,7 +203,7 @@ export const projectAssetImport = defineOperation({
   async impl(input, ctx) {
     const projectRoot = requireProjectRoot(ctx);
     if (!existsSync(input.sourcePath) || statSync(input.sourcePath).isDirectory()) {
-      throw new OperationError('SOURCE_NOT_FOUND', `Source file not found: ${input.sourcePath}`, {
+      throw new ToolError('SOURCE_NOT_FOUND', `Source file not found: ${input.sourcePath}`, {
         sourcePath: input.sourcePath,
       });
     }
@@ -211,7 +211,7 @@ export const projectAssetImport = defineOperation({
     const destAbs = resolveProjectPath(publicRoot, input.destPath);
     const destExists = existsSync(destAbs);
     if (destExists && !input.overwrite) {
-      throw new OperationError(
+      throw new ToolError(
         'DEST_EXISTS',
         `${input.destPath} already exists — pass overwrite:true to replace it.`,
         {
@@ -239,7 +239,7 @@ export const projectAssetImport = defineOperation({
 });
 
 /** Register every B2 `project.asset.*` operation onto `registry`. */
-export function registerAssetOperations(registry: OperationRegistry): void {
+export function registerAssetOperations(registry: ToolRegistry): void {
   registry.register(projectAssetList);
   registry.register(projectAssetInspect);
   registry.register(projectAssetImport);

package/src/project/component-operations.ts

@@ -13,8 +13,8 @@
 
 import type { SceneEntity } from '@vgai/engine/scene/scene-types';
 import { z } from 'zod';
-import { OperationError } from '../errors.js';
-import { defineOperation, type OperationRegistry } from '../registry.js';
+import { ToolError } from '../errors.js';
+import { defineTool, type ToolRegistry } from '../registry.js';
 import { finalizeSceneMutation } from './entity-operations.js';
 import {
   APPLY_DIFF_FAILED_ERROR,
@@ -77,7 +77,7 @@ const ProjectSceneComponentListInput = z.object({
   entityId: z.string().describe('Entity to list components for.'),
 });
 
-export const projectSceneComponentList = defineOperation({
+export const projectSceneComponentList = defineTool({
   name: 'project.scene.component.list',
   summary: 'List every component (by name) attached to an entity.',
   description: 'Read-only. Resolves the entity by stable id.',
@@ -127,7 +127,7 @@ const ComponentAfterSchema = z.object({
   data: z.unknown(),
 });
 
-export const projectSceneComponentAdd = defineOperation({
+export const projectSceneComponentAdd = defineTool({
   name: 'project.scene.component.add',
   summary: 'Attach a new named component to an entity.',
   description:
@@ -157,7 +157,7 @@ export const projectSceneComponentAdd = defineOperation({
     const entity = requireEntityById(scene.entities, input.entityId);
     const existing = entity.components ?? {};
     if (input.componentName in existing) {
-      throw new OperationError(
+      throw new ToolError(
         'COMPONENT_ALREADY_EXISTS',
         `Entity "${input.entityId}" already has a component named "${input.componentName}" — use project.scene.component.update instead.`,
         { entityId: input.entityId, componentName: input.componentName },
@@ -196,7 +196,7 @@ const ProjectSceneComponentUpdateInput = z.object({
   baseHash: BaseHashField,
 });
 
-export const projectSceneComponentUpdate = defineOperation({
+export const projectSceneComponentUpdate = defineTool({
   name: 'project.scene.component.update',
   summary: 'Merge field changes onto an existing named component.',
   description: 'Delegates to applyDiff’s `update` op with a merged components record.',
@@ -226,7 +226,7 @@ export const projectSceneComponentUpdate = defineOperation({
     const existing = entity.components ?? {};
     const currentData = existing[input.componentName];
     if (currentData === undefined) {
-      throw new OperationError(
+      throw new ToolError(
         'COMPONENT_NOT_FOUND',
         `Entity "${input.entityId}" has no component named "${input.componentName}".`,
         { entityId: input.entityId, componentName: input.componentName },
@@ -266,7 +266,7 @@ const ProjectSceneComponentRemoveInput = z.object({
   baseHash: BaseHashField,
 });
 
-export const projectSceneComponentRemove = defineOperation({
+export const projectSceneComponentRemove = defineTool({
   name: 'project.scene.component.remove',
   summary: 'Detach a named component from an entity.',
   description:
@@ -300,7 +300,7 @@ export const projectSceneComponentRemove = defineOperation({
     const existing = entity.components ?? {};
     const currentData = existing[input.componentName];
     if (currentData === undefined) {
-      throw new OperationError(
+      throw new ToolError(
         'COMPONENT_NOT_FOUND',
         `Entity "${input.entityId}" has no component named "${input.componentName}".`,
         { entityId: input.entityId, componentName: input.componentName },
@@ -329,7 +329,7 @@ export const projectSceneComponentRemove = defineOperation({
 });
 
 /** Register every B2 `project.scene.component.*` operation onto `registry`. */
-export function registerComponentOperations(registry: OperationRegistry): void {
+export function registerComponentOperations(registry: ToolRegistry): void {
   registry.register(projectSceneComponentList);
   registry.register(projectSceneComponentAdd);
   registry.register(projectSceneComponentUpdate);

package/src/project/discovery-operations.ts

@@ -26,8 +26,8 @@
 
 import { readFileSync } from 'node:fs';
 import { z } from 'zod';
-import { OperationError } from '../errors.js';
-import { defineOperation, type OperationRegistry } from '../registry.js';
+import { ToolError } from '../errors.js';
+import { defineTool, type ToolRegistry } from '../registry.js';
 import {
   listProjectFiles,
   NO_PROJECT_ROOT_ERROR,
@@ -40,7 +40,7 @@ import {
 // project.story.discover
 // ---------------------------------------------------------------------------
 
-export const projectStoryDiscover = defineOperation({
+export const projectStoryDiscover = defineTool({
   name: 'project.story.discover',
   summary: 'List every Storybook CSF story module (*.stories.tsx / *.stories.ts) in the project.',
   description:
@@ -68,7 +68,7 @@ export const projectStoryDiscover = defineOperation({
 // project.theatre.discover
 // ---------------------------------------------------------------------------
 
-export const projectTheatreDiscover = defineOperation({
+export const projectTheatreDiscover = defineTool({
   name: 'project.theatre.discover',
   summary:
     'List every committed Theatre project-state file (*.theatre-project.json) in the project.',
@@ -112,7 +112,7 @@ const ProjectTheatreValidateInput = z.object({
     .describe('Validate this raw document instead of reading `theatreProjectPath`.'),
 });
 
-export const projectTheatreValidate = defineOperation({
+export const projectTheatreValidate = defineTool({
   name: 'project.theatre.validate',
   summary:
     'Validate a Theatre project-state file’s OUTER shape (sheetsById/definitionVersion/revisionHistory).',
@@ -148,7 +148,7 @@ export const projectTheatreValidate = defineOperation({
       const absPath = resolveProjectPath(projectRoot, input.theatreProjectPath);
       json = JSON.parse(readFileSync(absPath, 'utf-8'));
     } else {
-      throw new OperationError(
+      throw new ToolError(
         'BAD_INPUT',
         'One of theatreProjectPath or document must be given.',
         {},
@@ -176,7 +176,7 @@ function looksLikeXStateMachine(text: string): { importsXstate: boolean; defines
   return { importsXstate, definesMachine };
 }
 
-export const projectXstateDiscover = defineOperation({
+export const projectXstateDiscover = defineTool({
   name: 'project.xstate.discover',
   summary:
     'Best-effort static discovery of TypeScript modules that appear to define an XState machine.',
@@ -230,7 +230,7 @@ const ProjectXstateValidateInput = z.object({
   machinePath: z.string().describe('Project-relative path to a TypeScript module to check.'),
 });
 
-export const projectXstateValidate = defineOperation({
+export const projectXstateValidate = defineTool({
   name: 'project.xstate.validate',
   summary:
     'Best-effort static check that a TypeScript module imports xstate and defines a machine.',
@@ -260,7 +260,7 @@ export const projectXstateValidate = defineOperation({
 });
 
 /** Register every B2 story/Theatre/XState discovery operation onto `registry`. */
-export function registerDiscoveryOperations(registry: OperationRegistry): void {
+export function registerDiscoveryOperations(registry: ToolRegistry): void {
   registry.register(projectStoryDiscover);
   registry.register(projectTheatreDiscover);
   registry.register(projectTheatreValidate);

package/src/project/entity-operations.ts

@@ -23,8 +23,8 @@ import type { applyDiff } from '@vgai/engine/scene/scene-apply';
 import type { SceneEntity } from '@vgai/engine/scene/scene-types';
 import { SceneEntitySchema } from '@vgai/engine/scene/schema/entity';
 import { z } from 'zod';
-import { OperationError } from '../errors.js';
-import { defineOperation, type OperationRegistry } from '../registry.js';
+import { ToolError } from '../errors.js';
+import { defineTool, type ToolRegistry } from '../registry.js';
 import {
   APPLY_DIFF_FAILED_ERROR,
   applyDiffOrThrow,
@@ -73,7 +73,7 @@ function finalizeSceneMutation<TBefore, TAfter>(
     parseSceneFile(result, scenePath);
   } catch (err) {
     if (err instanceof SceneParseError) {
-      throw new OperationError('SCENE_INVALID', `Result fails validation: ${err.message}`, {
+      throw new ToolError('SCENE_INVALID', `Result fails validation: ${err.message}`, {
         issues: err.issues.map((i) => `${i.path.join('.')}: ${i.message}`),
       });
     }
@@ -103,7 +103,7 @@ const ProjectSceneEntityAddInput = z.object({
   baseHash: BaseHashField,
 });
 
-export const projectSceneEntityAdd = defineOperation({
+export const projectSceneEntityAdd = defineTool({
   name: 'project.scene.entity.add',
   summary: 'Insert a new entity into a scene, by parent id + index.',
   description:
@@ -183,7 +183,7 @@ const ProjectSceneEntityUpdateInput = z.object({
   baseHash: BaseHashField,
 });
 
-export const projectSceneEntityUpdate = defineOperation({
+export const projectSceneEntityUpdate = defineTool({
   name: 'project.scene.entity.update',
   summary: 'Merge field changes onto an existing entity, addressed by stable id.',
   description:
@@ -252,7 +252,7 @@ const ProjectSceneEntityMoveInput = z.object({
   baseHash: BaseHashField,
 });
 
-export const projectSceneEntityMove = defineOperation({
+export const projectSceneEntityMove = defineTool({
   name: 'project.scene.entity.move',
   summary: 'Reparent and/or reorder an existing entity, addressed by stable id.',
   description: 'Builds a single `move` DiffOp and delegates to applyDiff.',
@@ -307,7 +307,7 @@ const ProjectSceneEntityRemoveInput = z.object({
   baseHash: BaseHashField,
 });
 
-export const projectSceneEntityRemove = defineOperation({
+export const projectSceneEntityRemove = defineTool({
   name: 'project.scene.entity.remove',
   summary: 'Delete an entity (and its subtree), addressed by stable id.',
   description: 'Builds a single `remove` DiffOp and delegates to applyDiff.',
@@ -354,7 +354,7 @@ export const projectSceneEntityRemove = defineOperation({
 });
 
 /** Register every B2 `project.scene.entity.*` operation onto `registry`. */
-export function registerEntityOperations(registry: OperationRegistry): void {
+export function registerEntityOperations(registry: ToolRegistry): void {
   registry.register(projectSceneEntityAdd);
   registry.register(projectSceneEntityUpdate);
   registry.register(projectSceneEntityMove);

package/src/project/index.ts

@@ -1,8 +1,8 @@
 /**
  * B2 — `project.*` operations
  * (docs/AI-NATIVE-AUTHORING-IMPLEMENTATION-SPEC.md §8 B2). Registered
- * SEPARATELY from B1's `registerBuiltinOperations` (see `../operations.ts`)
- * so B1's own registry tests — which assert `registerBuiltinOperations`
+ * SEPARATELY from B1's `registerBuiltinTools` (see `../operations.ts`)
+ * so B1's own registry tests — which assert `registerBuiltinTools`
  * registers "exactly the three B1 sample operations" — are unaffected; the
  * default `operations` singleton (`../index.ts`) calls both.
  */
@@ -37,7 +37,7 @@ export {
   writeFileAtomic,
 } from './shared.js';
 
-import type { OperationRegistry } from '../registry.js';
+import type { ToolRegistry } from '../registry.js';
 import { registerAssetOperations } from './asset-operations.js';
 import { registerComponentOperations } from './component-operations.js';
 import { registerDiscoveryOperations } from './discovery-operations.js';
@@ -48,7 +48,7 @@ import { registerManifestOperations } from './manifest-operations.js';
 import { registerSceneOperations } from './scene-operations.js';
 
 /** Register every B2 `project.*` operation onto `registry`. */
-export function registerProjectOperations(registry: OperationRegistry): void {
+export function registerProjectOperations(registry: ToolRegistry): void {
   registerManifestOperations(registry);
   registerSceneOperations(registry);
   registerEntityOperations(registry);

package/src/project/input-map-operations.ts

@@ -12,8 +12,8 @@
 
 import { InputMapFileSchema } from '@vgai/engine/input/schema';
 import { z } from 'zod';
-import { OperationError } from '../errors.js';
-import { defineOperation, type OperationRegistry } from '../registry.js';
+import { ToolError } from '../errors.js';
+import { defineTool, type ToolRegistry } from '../registry.js';
 import {
   BaseHashField,
   CONFLICT_ERROR,
@@ -51,7 +51,7 @@ const ProjectInputMapReadInput = z.object({
     ),
 });
 
-export const projectInputMapRead = defineOperation({
+export const projectInputMapRead = defineTool({
   name: 'project.inputMap.read',
   summary: 'Read + validate an .inputmap.json file.',
   description:
@@ -82,7 +82,7 @@ export const projectInputMapRead = defineOperation({
     const json: unknown = JSON.parse(raw);
     const parsed = InputMapFileSchema.safeParse(json);
     if (!parsed.success) {
-      throw new OperationError(
+      throw new ToolError(
         'INPUT_MAP_INVALID',
         `${input.inputMapPath} failed input-map validation.`,
         {
@@ -109,7 +109,7 @@ const ProjectInputMapValidateInput = z.object({
     .describe('Validate this raw document instead of reading `inputMapPath`.'),
 });
 
-export const projectInputMapValidate = defineOperation({
+export const projectInputMapValidate = defineTool({
   name: 'project.inputMap.validate',
   summary: 'Validate an input map file or raw document against the real input-map schema.',
   description:
@@ -142,7 +142,7 @@ export const projectInputMapValidate = defineOperation({
       const absPath = resolveProjectPath(projectRoot, input.inputMapPath);
       json = JSON.parse(readFileWithHash(absPath).raw);
     } else {
-      throw new OperationError('BAD_INPUT', 'One of inputMapPath or inputMap must be given.', {});
+      throw new ToolError('BAD_INPUT', 'One of inputMapPath or inputMap must be given.', {});
     }
     const parsed = InputMapFileSchema.safeParse(json);
     if (!parsed.success) return { valid: false, issues: formatIssues(parsed.error.issues) };
@@ -166,7 +166,7 @@ const ProjectInputMapUpdateInput = z.object({
   baseHash: BaseHashField,
 });
 
-export const projectInputMapUpdate = defineOperation({
+export const projectInputMapUpdate = defineTool({
   name: 'project.inputMap.update',
   summary: 'Add, replace, or delete actions in an input map — dry-run capable, conflict-checked.',
   description:
@@ -201,7 +201,7 @@ export const projectInputMapUpdate = defineOperation({
 
     const parsed = InputMapFileSchema.safeParse(merged);
     if (!parsed.success) {
-      throw new OperationError(
+      throw new ToolError(
         'INPUT_MAP_INVALID',
         'The patched input map failed schema validation.',
         {
@@ -226,7 +226,7 @@ export const projectInputMapUpdate = defineOperation({
 });
 
 /** Register every B2 `project.inputMap.*` operation onto `registry`. */
-export function registerInputMapOperations(registry: OperationRegistry): void {
+export function registerInputMapOperations(registry: ToolRegistry): void {
   registry.register(projectInputMapRead);
   registry.register(projectInputMapValidate);
   registry.register(projectInputMapUpdate);

package/src/project/inspection-operation.ts

@@ -1,7 +1,7 @@
 /** Read-only operation-registry projection of first-contact folder inspection. */
 
 import { z } from 'zod';
-import { defineOperation, type OperationRegistry } from '../registry.js';
+import { defineTool, type ToolRegistry } from '../registry.js';
 import { inspectProject, type ProjectInspection } from './inspection.js';
 import { nodeProjectInspectionReader } from './inspection-node.js';
 import { NO_PROJECT_ROOT_ERROR, requireProjectRoot } from './shared.js';
@@ -18,7 +18,7 @@ const ProjectInspectionResult = z.object({
   nextAction: z.string(),
 });
 
-export const projectInspect = defineOperation({
+export const projectInspect = defineTool({
   name: 'project.inspect',
   summary: 'Inspect this folder as a possible VGAI or existing browser-game project.',
   description:
@@ -38,6 +38,6 @@ export const projectInspect = defineOperation({
   },
 });
 
-export function registerInspectionOperations(registry: OperationRegistry): void {
+export function registerInspectionOperations(registry: ToolRegistry): void {
   registry.register(projectInspect);
 }

package/src/project/manifest-operations.ts

@@ -15,8 +15,8 @@ import { existsSync } from 'node:fs';
 import { loadGameManifest } from '@vgai/engine/manifest/load';
 import { GameManifestSchema } from '@vgai/engine/manifest/schema';
 import { z } from 'zod';
-import { OperationError } from '../errors.js';
-import { defineOperation, type OperationRegistry } from '../registry.js';
+import { ToolError } from '../errors.js';
+import { defineTool, type ToolRegistry } from '../registry.js';
 import {
   BaseHashField,
   CONFLICT_ERROR,
@@ -73,7 +73,7 @@ const ProjectDiscoverResult = z
   })
   .describe('A one-call survey of the project at ctx.projectRoot.');
 
-export const projectDiscover = defineOperation({
+export const projectDiscover = defineTool({
   name: 'project.discover',
   summary:
     "Survey a project's manifest, scenes, input maps, stories, and Theatre project state files.",
@@ -151,7 +151,7 @@ const ProjectManifestReadResult = z
   })
   .describe('Raw manifest read result.');
 
-export const projectManifestRead = defineOperation({
+export const projectManifestRead = defineTool({
   name: 'project.manifest.read',
   summary: 'Read the raw vgai.game.json manifest for the project.',
   description:
@@ -193,7 +193,7 @@ const ProjectManifestValidateResult = z
   })
   .describe('Structured manifest validation result — never throws for an invalid document.');
 
-export const projectManifestValidate = defineOperation({
+export const projectManifestValidate = defineTool({
   name: 'project.manifest.validate',
   summary: 'Validate the project manifest against the real engine schema + cross-field rules.',
   description:
@@ -272,7 +272,7 @@ const ProjectManifestUpdateResult = mutationResultSchema(
     .describe('The manifest document after the patch (or that WOULD result).'),
 );
 
-export const projectManifestUpdate = defineOperation({
+export const projectManifestUpdate = defineTool({
   name: 'project.manifest.update',
   summary: 'Patch name/version/resolution on vgai.game.json, dry-run capable, conflict-checked.',
   description:
@@ -311,7 +311,7 @@ export const projectManifestUpdate = defineOperation({
 
     const parsed = GameManifestSchema.safeParse(merged);
     if (!parsed.success) {
-      throw new OperationError(
+      throw new ToolError(
         'INVALID_MANIFEST',
         'The patched manifest failed schema validation.',
         {
@@ -324,7 +324,7 @@ export const projectManifestUpdate = defineOperation({
     try {
       loadGameManifest(merged);
     } catch (err) {
-      throw new OperationError(
+      throw new ToolError(
         'INVALID_MANIFEST',
         'The patched manifest failed cross-field validation.',
         {
@@ -349,7 +349,7 @@ export const projectManifestUpdate = defineOperation({
 });
 
 /** Register every B2 `project.discover` / `project.manifest.*` operation onto `registry`. */
-export function registerManifestOperations(registry: OperationRegistry): void {
+export function registerManifestOperations(registry: ToolRegistry): void {
   registry.register(projectDiscover);
   registry.register(projectManifestRead);
   registry.register(projectManifestValidate);

package/src/project/scene-operations.ts

@@ -24,8 +24,8 @@ import { ApplyDiffError, applyDiff } from '@vgai/engine/scene/scene-apply';
 import { SceneDiffSchema } from '@vgai/engine/scene/scene-diff-schema';
 import type { SceneFile } from '@vgai/engine/scene/scene-types';
 import { z } from 'zod';
-import { OperationError } from '../errors.js';
-import { defineOperation, type OperationRegistry } from '../registry.js';
+import { ToolError } from '../errors.js';
+import { defineTool, type ToolRegistry } from '../registry.js';
 import {
   BaseHashField,
   CONFLICT_ERROR,
@@ -102,7 +102,7 @@ export function readAndParseScene(
   try {
     json = JSON.parse(raw);
   } catch (err) {
-    throw new OperationError(
+    throw new ToolError(
       'SCENE_INVALID',
       `${scenePath} is not valid JSON: ${err instanceof Error ? err.message : err}`,
       {
@@ -115,7 +115,7 @@ export function readAndParseScene(
     return { absPath, hash, scene };
   } catch (err) {
     if (err instanceof SceneParseError) {
-      throw new OperationError('SCENE_INVALID', err.message, { issues: formatIssues(err.issues) });
+      throw new ToolError('SCENE_INVALID', err.message, { issues: formatIssues(err.issues) });
     }
     throw err;
   }
@@ -130,7 +130,7 @@ export function applyDiffOrThrow(
     return applyDiff(scene, patch);
   } catch (err) {
     if (err instanceof ApplyDiffError) {
-      throw new OperationError('APPLY_DIFF_FAILED', err.message, {
+      throw new ToolError('APPLY_DIFF_FAILED', err.message, {
         opIndex: err.opIndex,
         opType: err.opType,
         entityId: err.entityId,
@@ -159,7 +159,7 @@ const ProjectSceneReadResult = z
   })
   .describe('Scene read result.');
 
-export const projectSceneRead = defineOperation({
+export const projectSceneRead = defineTool({
   name: 'project.scene.read',
   summary: 'Read + validate a .vscn.json scene file.',
   description:
@@ -205,7 +205,7 @@ const ProjectSceneValidateResult = z
   .object({ valid: z.boolean(), issues: z.array(z.string()) })
   .describe('Structured validation result — never throws for a malformed scene.');
 
-export const projectSceneValidate = defineOperation({
+export const projectSceneValidate = defineTool({
   name: 'project.scene.validate',
   summary: 'Validate a scene file or raw scene document against the real scene schema.',
   description:
@@ -241,7 +241,7 @@ export const projectSceneValidate = defineOperation({
       }
       json = JSON.parse(readFileWithHash(absPath).raw);
     } else {
-      throw new OperationError('BAD_INPUT', 'One of scenePath or scene must be given.', {});
+      throw new ToolError('BAD_INPUT', 'One of scenePath or scene must be given.', {});
     }
 
     try {
@@ -279,7 +279,7 @@ const ProjectSceneDiffResult = z
   })
   .describe('What applying this patch would do — no write, ever.');
 
-export const projectSceneDiff = defineOperation({
+export const projectSceneDiff = defineTool({
   name: 'project.scene.diff',
   summary: 'Preview a SceneDiff patch against a scene file without writing anything.',
   description:
@@ -317,7 +317,7 @@ export const projectSceneDiff = defineOperation({
       return { wouldBeValid: true, issues: [], opCounts, entitiesTouched };
     } catch (err) {
       const message =
-        err instanceof OperationError
+        err instanceof ToolError
           ? err.message
           : err instanceof SceneParseError
             ? err.message
@@ -348,7 +348,7 @@ const ProjectSceneApplyResult = mutationResultSchema(
     .describe('The scene document after the patch (or that WOULD result).'),
 );
 
-export const projectSceneApply = defineOperation({
+export const projectSceneApply = defineTool({
   name: 'project.scene.apply',
   summary: 'Apply a SceneDiff patch to a scene file — dry-run capable, conflict-checked.',
   description:
@@ -381,7 +381,7 @@ export const projectSceneApply = defineOperation({
       parseSceneFile(result, input.scenePath);
     } catch (err) {
       if (err instanceof SceneParseError) {
-        throw new OperationError(
+        throw new ToolError(
           'SCENE_INVALID',
           `applyDiff produced a scene that fails validation: ${err.message}`,
           { issues: formatIssues(err.issues) },
@@ -394,7 +394,7 @@ export const projectSceneApply = defineOperation({
     // write (dry-run or real) exactly like `vgai apply-diff`.
     const refErrors = dereferenceNewAssetRefs(scene, result, absPath);
     if (refErrors.length > 0) {
-      throw new OperationError(
+      throw new ToolError(
         'ASSET_REF_INVALID',
         `The patch introduces ${refErrors.length} broken asset reference(s): ` +
           refErrors.map((e) => `${e.field} -> "${e.path}": ${e.reason}`).join('; '),
@@ -418,7 +418,7 @@ export const projectSceneApply = defineOperation({
 });
 
 /** Register every B2 `project.scene.*` operation onto `registry`. */
-export function registerSceneOperations(registry: OperationRegistry): void {
+export function registerSceneOperations(registry: ToolRegistry): void {
   registry.register(projectSceneRead);
   registry.register(projectSceneValidate);
   registry.register(projectSceneDiff);