@hybridlabor-api/aos 4.2.0 → 4.4.0

package/mcps/unreal_mcp/tests/mcp-tools/utility/behavior-tree-get-tree.test.mjs

@@ -1,233 +0,0 @@
-#!/usr/bin/env node
-/**
- * manage_behavior_tree.get_tree read introspection integration test.
- *
- * Builds a BT fixture (Root -> Selector -> Sequence -> Wait) with a root-level Service,
- * stacked edge decorators (Blackboard + CompareBBEntries + Cooldown) on the Selector->Sequence
- * edge, and a root-sentinel decorator, then calls get_tree and asserts the navigable hierarchy,
- * per-edge decorator attribution, multi-selector keyProperties (R16), and the null-RootNode
- * contract. Also asserts the get_ai_info BB enrichment added in PR1a.
- *
- * MUST run via the dev dist (the test runner spawns `node dist/cli.js`) — the Claude Code MCP
- * connection caches session-start TS (memory reference_claude_hook_timing). Build first:
- *   npm run build:core
- *   node tests/mcp-tools/utility/behavior-tree-get-tree.test.mjs
- *
- * Spec: docs/superpowers/specs/2026-05-03-bt-bb-introspect-design.md
- */
-
-import { runToolTests } from '../../test-runner.mjs';
-
-const ts = Date.now();
-const TEST_FOLDER = `/Game/MCPTest/GetTree_${ts}`;
-const TEST_FOLDER_ALIAS = TEST_FOLDER.slice(1); // leading-slash stripped (savePath form)
-const bbName = `BB_GetTreeFixture_${ts}`;
-const btName = `BT_GetTreeFixture_${ts}`;
-const btEmptyName = `BT_GetTreeEmpty_${ts}`;
-
-const testCases = [
-  // === SETUP ===
-  { scenario: 'Setup: folder', toolName: 'manage_asset',
-    arguments: { action: 'create_folder', path: TEST_FOLDER },
-    expected: 'success|already exists' },
-
-  { scenario: 'Setup: BB asset', toolName: 'manage_ai',
-    arguments: { action: 'create_blackboard_asset', name: bbName, path: TEST_FOLDER },
-    expected: 'success',
-    captureResult: { key: 'bbPath', fromField: 'result.blackboardPath' } },
-
-  { scenario: 'Setup: BB key Spotted (Bool)', toolName: 'manage_ai',
-    arguments: { action: 'add_blackboard_key', blackboardPath: '${captured:bbPath}',
-                 keyName: 'Spotted', keyType: 'Bool' },
-    expected: 'success' },
-
-  { scenario: 'Setup: BB key TargetActor (Object, baseObjectClass Actor)', toolName: 'manage_ai',
-    arguments: { action: 'add_blackboard_key', blackboardPath: '${captured:bbPath}',
-                 keyName: 'TargetActor', keyType: 'Object', baseObjectClass: 'Actor' },
-    expected: 'success' },
-
-  // BT via action='create' (graph-init Root node so RootNode is traversable; NOT create_behavior_tree)
-  { scenario: 'Setup: BT asset (via BT.create for BTGraph init)', toolName: 'manage_ai',
-    arguments: { action: 'create', name: btName, savePath: TEST_FOLDER_ALIAS },
-    expected: 'success',
-    captureResult: { key: 'btPath', fromField: 'result.assetPath' } },
-
-  { scenario: 'Setup: bind BT to BB', toolName: 'manage_ai',
-    arguments: { action: 'assign_blackboard', behaviorTreePath: '${captured:btPath}',
-                 blackboardPath: '${captured:bbPath}' },
-    expected: 'success',
-    assertions: [
-      { path: 'structuredContent.result.saved', equals: true, label: 'BT blackboard binding saved' }
-    ] },
-
-  // === Build: Root -> Selector -> Sequence -> Wait ===
-  { scenario: 'Build: add Selector', toolName: 'manage_ai',
-    arguments: { action: 'add_node', assetPath: '${captured:btPath}', nodeType: 'Selector' },
-    expected: 'success',
-    captureResult: { key: 'rootSelectorId', fromField: 'result.nodeId' } },
-
-  { scenario: 'Build: connect Root->Selector', toolName: 'manage_ai',
-    arguments: { action: 'connect_nodes', assetPath: '${captured:btPath}',
-                 parentNodeId: 'BehaviorTreeGraphNode_Root_0', childNodeId: '${captured:rootSelectorId}' },
-    expected: 'success' },
-
-  { scenario: 'Build: add Sequence', toolName: 'manage_ai',
-    arguments: { action: 'add_node', assetPath: '${captured:btPath}', nodeType: 'Sequence' },
-    expected: 'success',
-    captureResult: { key: 'sequenceId', fromField: 'result.nodeId' } },
-
-  { scenario: 'Build: connect Selector->Sequence', toolName: 'manage_ai',
-    arguments: { action: 'connect_nodes', assetPath: '${captured:btPath}',
-                 parentNodeId: '${captured:rootSelectorId}', childNodeId: '${captured:sequenceId}' },
-    expected: 'success' },
-
-  { scenario: 'Build: add Wait', toolName: 'manage_ai',
-    arguments: { action: 'add_node', assetPath: '${captured:btPath}', nodeType: 'Wait' },
-    expected: 'success',
-    captureResult: { key: 'waitId', fromField: 'result.nodeId' } },
-
-  { scenario: 'Build: connect Sequence->Wait', toolName: 'manage_ai',
-    arguments: { action: 'connect_nodes', assetPath: '${captured:btPath}',
-                 parentNodeId: '${captured:sequenceId}', childNodeId: '${captured:waitId}' },
-    expected: 'success' },
-
-  // === Subnodes ===
-  { scenario: 'Service DefaultFocus on Selector', toolName: 'manage_ai',
-    arguments: { action: 'add_subnode', assetPath: '${captured:btPath}',
-                 parentNodeId: '${captured:rootSelectorId}', subnodeType: 'Service', nodeClass: 'DefaultFocus' },
-    expected: 'success',
-    captureResult: { key: 'serviceId', fromField: 'result.nodeId' } },
-
-  { scenario: 'Service: set BlackboardKey=TargetActor', toolName: 'manage_ai',
-    arguments: { action: 'set_node_properties', assetPath: '${captured:btPath}',
-                 nodeId: '${captured:serviceId}', properties: { BlackboardKey: 'TargetActor' } },
-    expected: 'success' },
-
-  { scenario: 'Decorator Blackboard on Sequence', toolName: 'manage_ai',
-    arguments: { action: 'add_subnode', assetPath: '${captured:btPath}',
-                 parentNodeId: '${captured:sequenceId}', subnodeType: 'Decorator', nodeClass: 'Blackboard' },
-    expected: 'success',
-    captureResult: { key: 'bbDecId', fromField: 'result.nodeId' } },
-
-  { scenario: 'Decorator Blackboard: set BlackboardKey=Spotted', toolName: 'manage_ai',
-    arguments: { action: 'set_node_properties', assetPath: '${captured:btPath}',
-                 nodeId: '${captured:bbDecId}', properties: { BlackboardKey: 'Spotted' } },
-    expected: 'success' },
-
-  // R16: a 2-selector node (BlackboardKeyA + BlackboardKeyB) on the SAME edge
-  { scenario: 'Decorator CompareBBEntries on Sequence (R16 multi-selector)', toolName: 'manage_ai',
-    arguments: { action: 'add_subnode', assetPath: '${captured:btPath}',
-                 parentNodeId: '${captured:sequenceId}', subnodeType: 'Decorator', nodeClass: 'CompareBBEntries' },
-    expected: 'success',
-    captureResult: { key: 'cmpId', fromField: 'result.nodeId' } },
-
-  { scenario: 'CompareBBEntries: set BlackboardKeyA=Spotted', toolName: 'manage_ai',
-    arguments: { action: 'set_node_properties', assetPath: '${captured:btPath}',
-                 nodeId: '${captured:cmpId}', properties: { BlackboardKeyA: 'Spotted' } },
-    expected: 'success' },
-
-  { scenario: 'CompareBBEntries: set BlackboardKeyB=Spotted', toolName: 'manage_ai',
-    arguments: { action: 'set_node_properties', assetPath: '${captured:btPath}',
-                 nodeId: '${captured:cmpId}', properties: { BlackboardKeyB: 'Spotted' } },
-    expected: 'success' },
-
-  { scenario: 'Decorator Cooldown on Sequence (3rd edge decorator)', toolName: 'manage_ai',
-    arguments: { action: 'add_subnode', assetPath: '${captured:btPath}',
-                 parentNodeId: '${captured:sequenceId}', subnodeType: 'Decorator', nodeClass: 'Cooldown' },
-    expected: 'success' },
-
-  { scenario: 'Root-sentinel Decorator Cooldown (-> UBehaviorTree::RootDecorators)', toolName: 'manage_ai',
-    arguments: { action: 'add_subnode', assetPath: '${captured:btPath}',
-                 parentNodeId: 'root', subnodeType: 'Decorator', nodeClass: 'Cooldown' },
-    expected: 'success' },
-
-  // === get_tree assertions (paths under structuredContent.result.tree.*) ===
-  { scenario: 'get_tree returns navigable hierarchy', toolName: 'manage_ai',
-    arguments: { action: 'get_tree', assetPath: '${captured:btPath}' },
-    expected: 'success',
-    assertions: [
-      { path: 'structuredContent.result.tree.hasRootNode', equals: true,
-        label: 'hasRootNode true' },
-      { path: 'structuredContent.result.tree.rootNode.nodeClass', equals: 'BTComposite_Selector',
-        label: 'runtime root is the Selector composite' },
-      { path: 'structuredContent.result.tree.rootNode.nodeType', equals: 'composite',
-        label: 'root nodeType composite' },
-      { path: 'structuredContent.result.tree.rootNode.services',
-        includesObject: { nodeClass: 'BTService_DefaultFocus', keyProperties: { BlackboardKey: 'TargetActor' } },
-        label: 'root service resolves TargetActor' },
-      { path: 'structuredContent.result.tree.rootNode.children', length: 1,
-        label: 'Selector has exactly one child (Sequence)' },
-      { path: 'structuredContent.result.tree.rootNode.children.0.nodeClass', equals: 'BTComposite_Sequence',
-        label: 'child is the Sequence composite' },
-      { path: 'structuredContent.result.tree.rootNode.children.0.entryDecorators',
-        includesObject: { nodeClass: 'BTDecorator_Blackboard', keyProperties: { BlackboardKey: 'Spotted' } },
-        label: 'Sequence entry edge has Blackboard(Spotted)' },
-      { path: 'structuredContent.result.tree.rootNode.children.0.entryDecorators',
-        includesObject: { nodeClass: 'BTDecorator_CompareBBEntries',
-                          keyProperties: { BlackboardKeyA: 'Spotted', BlackboardKeyB: 'Spotted' } },
-        label: 'R16: CompareBBEntries exposes BOTH selectors' },
-      // NOTE: entryDecoratorOpsRaw is intentionally NOT asserted here. The Task 8 smoke probe
-      // confirmed UE leaves the postfix DecoratorOps array EMPTY for simple AND-stacked decorators
-      // (it is populated only for explicit decorator-logic composition: And/Or/Not grouping).
-      // The field still serializes correctly (as []); proving non-empty ops would require an
-      // editor-configured logic group, which no MCP authoring action exposes. (cross-model review F4)
-      { path: 'structuredContent.result.tree.rootNode.children.0.children.0.nodeClass', equals: 'BTTask_Wait',
-        label: 'Sequence leaf is the Wait task' },
-      { path: 'structuredContent.result.tree.rootNode.children.0.children.0.nodeType', equals: 'task',
-        label: 'leaf nodeType task' },
-      { path: 'structuredContent.result.tree.rootDecorators',
-        includesObject: { nodeClass: 'BTDecorator_Cooldown' },
-        label: 'root-sentinel decorator surfaced in rootDecorators' }
-    ] },
-
-  // === get_ai_info BB enrichment (PR1a adds inherited/sourceBlackboard via shared serializer) ===
-  // We assert the deterministic `inherited:false` enrichment field, NOT `baseClass`: the
-  // add_blackboard_key authoring action does not set UBlackboardKeyType_Object::BaseClass
-  // (AIHandlers.cpp:957-960 reads baseObjectClass but never assigns it — "Could set base class
-  // here"), so baseClass is non-deterministic (default Object / absent). The serializer's
-  // baseClass code is correct; there is just no MCP path to populate BaseClass for this fixture.
-  // Populating BaseClass (and thus a baseClass assertion) is a separate authoring gap, out of
-  // PR1a scope. (cross-model review F2)
-  { scenario: 'get_ai_info BB enrichment: per-key inherited flag present', toolName: 'manage_ai',
-    arguments: { action: 'get_ai_info', blackboardPath: '${captured:bbPath}' },
-    expected: 'success',
-    assertions: [
-      { path: 'structuredContent.result.aiInfo.blackboardKeys',
-        includesObject: { name: 'TargetActor', type: 'BlackboardKeyType_Object', inherited: false },
-        label: 'enrichment present: TargetActor is own (non-inherited) key' }
-    ] },
-
-  // === Null-RootNode contract: a graphless BT (create_behavior_tree leaves BTGraph/RootNode null) ===
-  // NOTE: create_behavior_tree returns its path under result.behaviorTreePath (AIHandlers.cpp:1067),
-  // NOT result.assetPath (that is the BT.create SubAction's field, used for btPath above).
-  { scenario: 'Setup: empty BT via create_behavior_tree (graphless)', toolName: 'manage_ai',
-    arguments: { action: 'create_behavior_tree', name: btEmptyName, path: TEST_FOLDER },
-    expected: 'success',
-    captureResult: { key: 'btEmptyPath', fromField: 'result.behaviorTreePath' } },
-
-  { scenario: 'get_tree on graphless BT returns null-RootNode contract (success, not error)',
-    toolName: 'manage_ai',
-    arguments: { action: 'get_tree', assetPath: '${captured:btEmptyPath}' },
-    expected: 'success',
-    assertions: [
-      { path: 'structuredContent.result.tree.hasRootNode', equals: false,
-        label: 'graphless BT -> hasRootNode false (no GRAPH_NOT_FOUND error)' },
-      { path: 'structuredContent.result.tree.executionNodeCount', equals: 0,
-        label: 'graphless BT -> executionNodeCount 0' }
-    ] },
-
-  // === Cleanup (assets first, then folder is left for the runner / next-run uniqueness) ===
-  { scenario: 'Cleanup: delete BT', toolName: 'manage_asset',
-    arguments: { action: 'delete', assetPath: '${captured:btPath}', force: true },
-    expected: 'success|not found' },
-
-  { scenario: 'Cleanup: delete empty BT', toolName: 'manage_asset',
-    arguments: { action: 'delete', assetPath: '${captured:btEmptyPath}', force: true },
-    expected: 'success|not found' },
-
-  { scenario: 'Cleanup: delete BB', toolName: 'manage_asset',
-    arguments: { action: 'delete', assetPath: '${captured:bbPath}', force: true },
-    expected: 'success|not found' },
-];
-
-await runToolTests('manage_behavior_tree.get_tree', testCases);

package/mcps/unreal_mcp/tests/mcp-tools/utility/manage-audio.test.mjs

@@ -1,160 +0,0 @@
-#!/usr/bin/env node
-
-import { runToolTests } from '../../test-runner.mjs';
-
-const TEST_FOLDER = '/Game/MCPTest/AuthoringAssets';
-const TEST_FOLDER_ALIAS = TEST_FOLDER.slice(1);
-const ts = Date.now();
-const FADE_ACTOR_NAME = `MCPTestAudioActor_${ts}`;
-const SOUND_CUE = `${TEST_FOLDER}/TestSoundCue`;
-const SOUND_CLASS = `${TEST_FOLDER}/TestSoundClass`;
-const SOUND_MIX = `${TEST_FOLDER}/TestSoundMix`;
-const METASOUND = `${TEST_FOLDER}/TestMetaSound`;
-const ATTENUATION = `${TEST_FOLDER}/TestAttenuation`;
-const DIALOGUE_VOICE = `${TEST_FOLDER}/TestDialogueVoice`;
-const DIALOGUE_WAVE = `${TEST_FOLDER}/TestDialogueWave`;
-const REVERB_EFFECT = `${TEST_FOLDER}/TestReverbEffect`;
-const SOURCE_EFFECT_CHAIN = `${TEST_FOLDER}/TestSourceEffectChain`;
-const SOUND_WAVE = '/Engine/VREditor/Sounds/VR_click1.VR_click1';
-
-const testCases = [
-// === SETUP ===
-{ scenario: 'Setup: create test folder', toolName: 'manage_asset', arguments: { action: 'create_folder', path: TEST_FOLDER }, expected: 'success|already exists' },
-{ scenario: 'Setup: create test sound cue', toolName: 'manage_audio', arguments: { action: 'create_sound_cue', name: 'TestSoundCue', path: TEST_FOLDER_ALIAS }, expected: 'success|already exists' },
-{ scenario: 'Setup: create test sound class', toolName: 'manage_audio', arguments: { action: 'create_sound_class', name: 'TestSoundClass', path: TEST_FOLDER }, expected: 'success|already exists' },
-{ scenario: 'Setup: create test sound mix', toolName: 'manage_audio', arguments: { action: 'create_sound_mix', name: 'TestSoundMix', path: TEST_FOLDER }, expected: 'success|already exists' },
-{ scenario: 'Setup: create test metasound', toolName: 'manage_audio', arguments: { action: 'create_metasound', name: 'TestMetaSound', path: TEST_FOLDER_ALIAS }, expected: 'success|already exists' },
-{ scenario: 'Setup: create test attenuation settings', toolName: 'manage_audio', arguments: { action: 'create_attenuation_settings', name: 'TestAttenuation', path: TEST_FOLDER }, expected: 'success|already exists' },
-{ scenario: 'Setup: create test dialogue voice', toolName: 'manage_audio', arguments: { action: 'create_dialogue_voice', name: 'TestDialogueVoice', path: TEST_FOLDER }, expected: 'success|already exists' },
-{ scenario: 'Setup: create test dialogue wave', toolName: 'manage_audio', arguments: { action: 'create_dialogue_wave', name: 'TestDialogueWave', path: TEST_FOLDER }, expected: 'success|already exists' },
-{ scenario: 'Setup: create test reverb effect', toolName: 'manage_audio', arguments: { action: 'create_reverb_effect', name: 'TestReverbEffect', path: TEST_FOLDER }, expected: 'success|already exists' },
-{ scenario: 'Setup: create test source effect chain', toolName: 'manage_audio', arguments: { action: 'create_source_effect_chain', name: 'TestSourceEffectChain', path: TEST_FOLDER }, expected: 'success|already exists' },
-
-// Spawn actor for fade/attached tests — requires classPath
-{ scenario: 'Setup: spawn actor for fade tests', toolName: 'control_actor', arguments: { action: 'spawn', name: FADE_ACTOR_NAME, classPath: '/Script/Engine.Actor', location: [0, 0, 0] }, expected: 'success|already exists' },
-
-// Create AudioComponent on the spawned actor
-{ scenario: 'Setup: create audio component on actor', toolName: 'manage_audio', arguments: { action: 'create_audio_component', soundPath: SOUND_CUE, actorName: FADE_ACTOR_NAME }, expected: 'success', captureResult: { key: 'audioComponentName', fromField: 'result.componentName' } },
-
-// Add nodes to SoundCue for connect test
-// C++ handler reads nodeType.ToLower() and matches 'random', 'waveplayer', 'modulator', etc.
-{ scenario: 'Setup: add random node to sound cue', toolName: 'manage_audio', arguments: { action: 'add_cue_node', assetPath: SOUND_CUE, nodeType: 'random' }, expected: 'success|already exists' },
-{ scenario: 'Setup: add wave player node to sound cue', toolName: 'manage_audio', arguments: { action: 'add_cue_node', assetPath: SOUND_CUE, nodeType: 'wave_player' }, expected: 'success|already exists' },
-
-// MetaSound nodes — C++ maps nodeType to 3-part class names:
-// 'sine' → {UE, Sine, Audio}, 'multiply'/'gain' → {UE, Multiply, Float}
-{ scenario: 'Setup: add sine node to metasound', toolName: 'manage_audio', arguments: { action: 'add_metasound_node', assetPath: METASOUND, nodeType: 'sine' }, expected: 'success', captureResult: { key: 'sineNodeId', fromField: 'result.nodeId' } },
-{ scenario: 'Setup: add gain node to metasound', toolName: 'manage_audio', arguments: { action: 'add_metasound_node', assetPath: METASOUND, nodeType: 'gain' }, expected: 'success', captureResult: { key: 'gainNodeId', fromField: 'result.nodeId' } },
-{ scenario: 'Setup: add alias add node to metasound', toolName: 'manage_audio', arguments: { action: 'add_metasound_node', assetPath: METASOUND, nodeType: 'add' }, expected: 'success', captureResult: { key: 'aliasAddNodeId', fromField: 'result.nodeId' } },
-{ scenario: 'Setup: add alias gain node to metasound', toolName: 'manage_audio', arguments: { action: 'add_metasound_node', assetPath: METASOUND, nodeType: 'gain' }, expected: 'success', captureResult: { key: 'aliasGainNodeId', fromField: 'result.nodeId' } },
-{ scenario: 'Setup: add input to metasound', toolName: 'manage_audio', arguments: { action: 'add_metasound_input', assetPath: METASOUND, inputName: 'TestFrequency', inputType: 'Float' }, expected: 'success|already exists' },
-
-// === CREATE ===
-{ scenario: 'CREATE: create_sound_cue', toolName: 'manage_audio', arguments: { action: 'create_sound_cue', name: `Testsound_cue_${ts}`, path: '/Game/MCPTest', wavePath: SOUND_WAVE, looping: true }, expected: 'success|already exists' },
-{ scenario: 'CREATE: create_audio_component', toolName: 'manage_audio', arguments: { action: 'create_audio_component', soundPath: SOUND_CUE }, expected: 'success' },
-{ scenario: 'CREATE: create_sound_mix', toolName: 'manage_audio', arguments: { action: 'create_sound_mix', name: `Testsound_mix_${ts}`, path: '/Game/MCPTest' }, expected: 'success|already exists' },
-{ scenario: 'CREATE: create_sound_class', toolName: 'manage_audio', arguments: { action: 'create_sound_class', name: `Testsound_class_${ts}`, path: '/Game/MCPTest', properties: { volume: 0.9, pitch: 1.05 } }, expected: 'success|already exists' },
-
-// === PLAYBACK === (uses ResolveSoundAsset - accepts package path)
-{ scenario: 'PLAYBACK: play_sound_at_location', toolName: 'manage_audio', arguments: { action: 'play_sound_at_location', soundPath: SOUND_CUE, location: { x: 0, y: 0, z: 0 }, rotation: { pitch: 0, yaw: 45, roll: 0 }, startTime: 0.0, concurrencyPath: '/Game/MCPTest/AuthoringAssets/MissingConcurrency.MissingConcurrency' }, expected: 'success' },
-{ scenario: 'PLAYBACK: play_sound_2d', toolName: 'manage_audio', arguments: { action: 'play_sound_2d', soundPath: SOUND_CUE }, expected: 'success' },
-{ scenario: 'PLAYBACK: play_sound_attached', toolName: 'manage_audio', arguments: { action: 'play_sound_attached', soundPath: SOUND_CUE, actorName: FADE_ACTOR_NAME, attachPointName: 'McpAudioRoot' }, expected: 'success' },
-{ scenario: 'CREATE: spawn_sound_at_location', toolName: 'manage_audio', arguments: { action: 'spawn_sound_at_location', soundPath: SOUND_CUE, location: [0, 0, 100] }, expected: 'success' },
-{ scenario: 'ACTION: prime_sound', toolName: 'manage_audio', arguments: { action: 'prime_sound', soundPath: SOUND_CUE }, expected: 'success' },
-
-// === SOUND MIX CONTROL === (uses ResolveSoundMix/Class - accepts simple names)
-{ scenario: 'ACTION: push_sound_mix', toolName: 'manage_audio', arguments: { action: 'push_sound_mix', mixName: 'TestSoundMix' }, expected: 'success' },
-{ scenario: 'ACTION: pop_sound_mix', toolName: 'manage_audio', arguments: { action: 'pop_sound_mix', mixName: 'TestSoundMix' }, expected: 'success' },
-{ scenario: 'CONFIG: set_sound_mix_class_override', toolName: 'manage_audio', arguments: { action: 'set_sound_mix_class_override', mixName: 'TestSoundMix', soundClassName: 'TestSoundClass', volume: 0.8, pitch: 1.0, fadeInTime: 0.25 }, expected: 'success' },
-{ scenario: 'DELETE: clear_sound_mix_class_override', toolName: 'manage_audio', arguments: { action: 'clear_sound_mix_class_override', mixName: 'TestSoundMix', soundClassName: 'TestSoundClass', fadeOutTime: 0.25 }, expected: 'success' },
-{ scenario: 'CONFIG: set_base_sound_mix', toolName: 'manage_audio', arguments: { action: 'set_base_sound_mix', mixName: 'TestSoundMix' }, expected: 'success' },
-
-// === SOUND FADING === (C++ handler now accepts componentName for targeted search)
-{ scenario: 'ACTION: fade_sound_in', toolName: 'manage_audio', arguments: { action: 'fade_sound_in', actorName: FADE_ACTOR_NAME, componentName: '${captured:audioComponentName}', fadeTime: 1.0 }, expected: 'success' },
-{ scenario: 'ACTION: fade_sound_out', toolName: 'manage_audio', arguments: { action: 'fade_sound_out', actorName: FADE_ACTOR_NAME, componentName: '${captured:audioComponentName}', fadeTime: 1.0 }, expected: 'success' },
-// fade_sound: C++ reads soundName (preferred) or actorName
-{ scenario: 'ACTION: fade_sound', toolName: 'manage_audio', arguments: { action: 'fade_sound', soundName: FADE_ACTOR_NAME, componentName: '${captured:audioComponentName}', fadeTime: 1.0, targetVolume: 0.5, fadeType: 'FadeTo' }, expected: 'success' },
-
-// === AMBIENT & REVERB ===
-{ scenario: 'CREATE: create_ambient_sound', toolName: 'manage_audio', arguments: { action: 'create_ambient_sound', soundPath: SOUND_CUE, location: [0, 0, 0] }, expected: 'success' },
-{ scenario: 'CREATE: create_reverb_zone', toolName: 'manage_audio', arguments: { action: 'create_reverb_zone', name: `Testreverb_zone_${ts}`, location: [0, 0, 0], size: [500, 500, 500], reverbEffect: REVERB_EFFECT }, expected: 'success|already exists' },
-
-// === ATTENUATION ===
-{ scenario: 'CONFIG: set_sound_attenuation', toolName: 'manage_audio', arguments: { action: 'set_sound_attenuation', name: `TestSetAttenuation_${ts}`, innerRadius: 400, falloffDistance: 3600, attenuationShape: 'Box', falloffMode: 'Inverse', path: TEST_FOLDER, save: false }, expected: 'success', assertions: [{ path: 'structuredContent.result.existsAfter', equals: true, label: 'attenuation asset configured in editor asset registry' }, { path: 'structuredContent.result.attenuationShape', equals: 'Box', label: 'attenuation shape applied' }, { path: 'structuredContent.result.falloffMode', equals: 'Inverse', label: 'falloff mode applied' }] },
-
-// === TOGGLE ===
-{ scenario: 'TOGGLE: enable_audio_analysis', toolName: 'manage_audio', arguments: { action: 'enable_audio_analysis', enable: true }, expected: 'success' },
-{ scenario: 'TOGGLE: enable_audio_analysis alias', toolName: 'manage_audio', arguments: { action: 'enable_audio_analysis', enabled: false, analysisType: 'Amplitude', windowSize: 2048 }, expected: 'success' },
-
-// === CONFIG ===
-{ scenario: 'CONFIG: set_doppler_effect', toolName: 'manage_audio', arguments: { action: 'set_doppler_effect', dopplerIntensity: 1, velocityScale: 1 }, expected: 'success' },
-{ scenario: 'CONFIG: set_audio_occlusion', toolName: 'manage_audio', arguments: { action: 'set_audio_occlusion', enable: true, occlusionVolumeScale: 0.5, occlusionFilterScale: 0.5, occlusionInterpolationTime: 0.1 }, expected: 'success' },
-
-// === SOUND CUE AUTHORING === (uses StaticLoadObject - TS normalizes paths)
-{ scenario: 'ADD: add_cue_node', toolName: 'manage_audio', arguments: { action: 'add_cue_node', assetPath: SOUND_CUE, nodeType: 'modulator' }, expected: 'success|already exists' },
-
-// connect_cue_nodes: C++ uses graph pin linking + CompileSoundNodesFromGraphNodes
-// UE assigns node names like SoundNodeRandom_0 for the first Random node
-{ scenario: 'CONNECT: connect_cue_nodes', toolName: 'manage_audio', arguments: { action: 'connect_cue_nodes', assetPath: SOUND_CUE, sourceNodeId: 'SoundNodeRandom_0', targetNodeId: 'SoundNodeWavePlayer_0' }, expected: 'success' },
-
-{ scenario: 'CONFIG: set_cue_attenuation', toolName: 'manage_audio', arguments: { action: 'set_cue_attenuation', assetPath: SOUND_CUE, attenuationPath: ATTENUATION }, expected: 'success' },
-{ scenario: 'CONFIG: set_cue_concurrency', toolName: 'manage_audio', arguments: { action: 'set_cue_concurrency', assetPath: SOUND_CUE, concurrencyPath: '/Game/MCPTest/AuthoringAssets/MissingConcurrency.MissingConcurrency' }, expected: 'success' },
-
-// === METASOUND AUTHORING ===
-{ scenario: 'CREATE: create_metasound', toolName: 'manage_audio', arguments: { action: 'create_metasound', name: `Testmetasound_${ts}`, path: '/Game/MCPTest' }, expected: 'success|already exists' },
-
-// add_metasound_node: C++ maps 'add' → {UE, Add, Float}
-{ scenario: 'ADD: add_metasound_node', toolName: 'manage_audio', arguments: { action: 'add_metasound_node', assetPath: METASOUND, nodeType: 'add' }, expected: 'success', captureResult: { key: 'addNodeId', fromField: 'result.nodeId' } },
-
-// connect_metasound_nodes: C++ requires GUID node IDs from add_metasound_node responses
-// Capture real GUIDs from setup and use them for the connection test
-{ scenario: 'CONNECT: connect_metasound_nodes', toolName: 'manage_audio', arguments: { action: 'connect_metasound_nodes', assetPath: METASOUND, sourceNodeId: '${captured:addNodeId}', sourceOutputName: 'Out', targetNodeId: '${captured:gainNodeId}', targetInputName: 'AdditionalOperands' }, expected: 'success' },
-{ scenario: 'CONNECT: connect_metasound_nodes aliases', toolName: 'manage_audio', arguments: { action: 'connect_metasound_nodes', assetPath: METASOUND, sourceNode: '${captured:aliasAddNodeId}', sourcePin: 'Out', targetNode: '${captured:aliasGainNodeId}', targetPin: 'AdditionalOperands' }, expected: 'success' },
-
-{ scenario: 'ADD: add_metasound_output', toolName: 'manage_audio', arguments: { action: 'add_metasound_output', assetPath: METASOUND, outputName: `TestOutput_${ts}`, outputType: 'Audio' }, expected: 'success' },
-
-// set_metasound_default: TS remaps defaultValue→floatValue. C++ reads floatValue.
-{ scenario: 'CONFIG: set_metasound_default', toolName: 'manage_audio', arguments: { action: 'set_metasound_default', assetPath: METASOUND, inputName: 'TestFrequency', defaultValue: 440.0 }, expected: 'success' },
-
-// === SOUND CLASS & MIX AUTHORING ===
-{ scenario: 'CONFIG: set_class_properties', toolName: 'manage_audio', arguments: { action: 'set_class_properties', assetPath: SOUND_CLASS, volume: 0.8, pitch: 1.0, lowPassFilterFrequency: 18000 }, expected: 'success', assertions: [{ path: 'structuredContent.result.lowPassFilterFrequency', equals: 18000, label: 'low-pass filter frequency applied' }] },
-// set_class_parent: TS remaps parentClass→parentPath. C++ reads parentPath.
-{ scenario: 'CONFIG: set_class_parent', toolName: 'manage_audio', arguments: { action: 'set_class_parent', assetPath: SOUND_CLASS, parentClass: '/Script/Engine.SoundClass' }, expected: 'success' },
-{ scenario: 'ADD: add_mix_modifier', toolName: 'manage_audio', arguments: { action: 'add_mix_modifier', assetPath: SOUND_MIX, soundClassPath: SOUND_CLASS, volumeAdjuster: 0.8 }, expected: 'success|already exists' },
-{ scenario: 'CONFIG: configure_mix_eq', toolName: 'manage_audio', arguments: { action: 'configure_mix_eq', assetPath: SOUND_MIX }, expected: 'success' },
-
-// === ATTENUATION AUTHORING ===
-{ scenario: 'CREATE: create_attenuation_settings', toolName: 'manage_audio', arguments: { action: 'create_attenuation_settings', name: `Testattenuation_settings_${ts}`, path: '/Game/MCPTest' }, expected: 'success|already exists' },
-{ scenario: 'CONFIG: configure_distance_attenuation', toolName: 'manage_audio', arguments: { action: 'configure_distance_attenuation', assetPath: ATTENUATION, innerRadius: 400, falloffDistance: 3600 }, expected: 'success' },
-// configure_spatialization: TS remaps spatialization→spatialize+spatializationAlgorithm. C++ reads both.
-{ scenario: 'CONFIG: configure_spatialization', toolName: 'manage_audio', arguments: { action: 'configure_spatialization', assetPath: ATTENUATION, spatialization: 'HRTF' }, expected: 'success' },
-// configure_occlusion: TS remaps enable→enableOcclusion. C++ reads enableOcclusion.
-{ scenario: 'CONFIG: configure_occlusion', toolName: 'manage_audio', arguments: { action: 'configure_occlusion', assetPath: ATTENUATION, enable: true }, expected: 'success' },
-
-// configure_reverb_send: C++ reads enableReverbSend, reverbWetLevelMin, reverbWetLevelMax, etc.
-{ scenario: 'CONFIG: configure_reverb_send', toolName: 'manage_audio', arguments: { action: 'configure_reverb_send', assetPath: ATTENUATION, enableReverbSend: true, reverbWetLevelMin: 0.3, reverbWetLevelMax: 0.95, reverbDistanceMin: 100, reverbDistanceMax: 5000 }, expected: 'success' },
-
-// === DIALOGUE ===
-{ scenario: 'CREATE: create_dialogue_voice', toolName: 'manage_audio', arguments: { action: 'create_dialogue_voice', name: `Testdialogue_voice_${ts}`, path: '/Game/MCPTest' }, expected: 'success|already exists' },
-{ scenario: 'CREATE: create_dialogue_wave', toolName: 'manage_audio', arguments: { action: 'create_dialogue_wave', name: `Testdialogue_wave_${ts}`, path: '/Game/MCPTest' }, expected: 'success|already exists' },
-{ scenario: 'CONFIG: set_dialogue_context', toolName: 'manage_audio', arguments: { action: 'set_dialogue_context', assetPath: DIALOGUE_WAVE, speakerPath: DIALOGUE_VOICE }, expected: 'success' },
-
-// === EFFECTS ===
-{ scenario: 'CREATE: create_reverb_effect', toolName: 'manage_audio', arguments: { action: 'create_reverb_effect', name: `Testreverb_effect_${ts}`, path: '/Game/MCPTest' }, expected: 'success|already exists' },
-{ scenario: 'CREATE: create_source_effect_chain', toolName: 'manage_audio', arguments: { action: 'create_source_effect_chain', name: `Testsource_effect_chain_${ts}`, path: '/Game/MCPTest' }, expected: 'success|already exists' },
-
-// add_source_effect: Now routes through authoring handler.
-// C++ authoring handler reads assetPath + effectType. Creates preset internally.
-{ scenario: 'ADD: add_source_effect', toolName: 'manage_audio', arguments: { action: 'add_source_effect', assetPath: SOURCE_EFFECT_CHAIN, effectType: 'EQ' }, expected: 'success' },
-
-{ scenario: 'CREATE: create_submix_effect', toolName: 'manage_audio', arguments: { action: 'create_submix_effect', name: `Testsubmix_effect_${ts}`, path: '/Game/MCPTest', effectType: 'Reverb' }, expected: 'success|already exists' },
-
-// === INFO ===
-{ scenario: 'INFO: get_audio_info', toolName: 'manage_audio', arguments: { action: 'get_audio_info', assetPath: SOUND_CUE }, expected: 'success' },
-
-// === CLEANUP ===
-// In-memory assets may not unload properly — DELETE_FAILED is acceptable
-{ scenario: 'Cleanup: delete test folder', toolName: 'manage_asset', arguments: { action: 'delete', path: TEST_FOLDER, force: true }, expected: 'DELETE_FAILED|success|not found' },
-];
-
-runToolTests('manage-audio', testCases);

package/mcps/unreal_mcp/tests/mcp-tools/utility/manage-behavior-tree.test.mjs

@@ -1,223 +0,0 @@
-#!/usr/bin/env node
-/**
- * manage_behavior_tree subnode authoring integration test (PR0b).
- *
- * Exercises the four fixture patterns PR1a's live test will depend on:
- *   - Scenario A: root-level Service with FBlackboardKeySelector binding (TargetActor)
- *   - Scenario B: non-root edge decorator stacking with BB-key (Spotted) + Cooldown
- *   - Scenario C: root decorator via "root" sentinel
- *   - Negative: invalid GUID parentNodeId -> INVALID_PARENT
- *
- * Spec: docs/superpowers/specs/2026-05-03-pr0b-bt-authoring-subnode-design.md
- *
- * Test notes:
- *
- *   1. BT must be created via manage_ai action='create' (which routes through
- *      behaviorTreeActionSet to the BT.create SubAction), NOT
- *      action='create_behavior_tree'. The latter goes through AIHandlers and
- *      uses Asset Tools without initializing BTGraph; downstream BT SubActions
- *      then fail with GRAPH_NOT_FOUND.
- *
- *   2. The fixture binds the newly created BT to the newly created BB before
- *      setting BlackboardKey properties, so FBlackboardKeySelector resolution
- *      runs against known keys.
- *
- *   3. runToolTests matcher quirk: lowerReason for primary error-type match
- *      uses the response *message* (not error code) when message is non-empty.
- *      The INVALID_PARENT negative test accepts either the error code or
- *      the substring `not found` (which is in the engine's reply message)
- *      so the matcher path resolves cleanly regardless of which side carries
- *      the discriminating word.
- *
- *   4. btNodeCount is intentionally not asserted here. The diagnostics below
- *      focus on the BB binding, FBlackboardKeySelector resolution, and root
- *      decorator propagation contracts covered by this fixture.
- */
-
-import { runToolTests } from '../../test-runner.mjs';
-
-const ts = Date.now();
-const TEST_FOLDER = `/Game/MCPTest/BTSubnode_${ts}`;
-const TEST_FOLDER_ALIAS = TEST_FOLDER.slice(1);
-const bbName = `BB_PR0bFixture_${ts}`;
-const btName = `BT_PR0bFixture_${ts}`;
-
-const testCases = [
-  // === SETUP ===
-  { scenario: 'Setup: folder', toolName: 'manage_asset',
-    arguments: { action: 'create_folder', path: TEST_FOLDER },
-    expected: 'success|already exists' },
-
-  { scenario: 'Setup: BB asset', toolName: 'manage_ai',
-    arguments: { action: 'create_blackboard_asset', name: bbName, path: TEST_FOLDER },
-    expected: 'success',
-    captureResult: { key: 'bbPath', fromField: 'result.blackboardPath' } },
-
-  { scenario: 'Setup: BB key Spotted (Bool)', toolName: 'manage_ai',
-    arguments: { action: 'add_blackboard_key', blackboardPath: '${captured:bbPath}',
-                 keyName: 'Spotted', keyType: 'Bool' },
-    expected: 'success' },
-
-  { scenario: 'Setup: BB key TargetActor (Object)', toolName: 'manage_ai',
-    arguments: { action: 'add_blackboard_key', blackboardPath: '${captured:bbPath}',
-                 keyName: 'TargetActor', keyType: 'Object' },
-    expected: 'success' },
-
-  // BT must use action='create' (BT.create SubAction routes via behaviorTreeActionSet,
-  // initializes BTGraph + default Root node). See header note 1.
-  { scenario: 'Setup: BT asset (via BT.create for BTGraph init)',
-    toolName: 'manage_ai',
-    arguments: { action: 'create', name: btName, savePath: TEST_FOLDER_ALIAS },
-    expected: 'success',
-    captureResult: { key: 'btPath', fromField: 'result.assetPath' } },
-
-  { scenario: 'Setup: bind BT to BB', toolName: 'manage_ai',
-    arguments: { action: 'assign_blackboard', behaviorTreePath: '${captured:btPath}',
-                 blackboardPath: '${captured:bbPath}' },
-    expected: 'success',
-    assertions: [
-      { path: 'structuredContent.result.saved', equals: true,
-        label: 'BT blackboard binding saved' }
-    ] },
-
-  // === Build BT structure: Selector -> Sequence -> Wait ===
-  { scenario: 'Build: add Selector', toolName: 'manage_ai',
-    arguments: { action: 'add_node', assetPath: '${captured:btPath}', nodeType: 'Selector' },
-    expected: 'success',
-    captureResult: { key: 'rootSelectorId', fromField: 'result.nodeId' } },
-
-  { scenario: 'Build: connect Root->Selector', toolName: 'manage_ai',
-    arguments: { action: 'connect_nodes', assetPath: '${captured:btPath}',
-                 parentNodeId: 'BehaviorTreeGraphNode_Root_0',
-                 childNodeId: '${captured:rootSelectorId}' },
-    expected: 'success' },
-
-  { scenario: 'Build: add Sequence', toolName: 'manage_ai',
-    arguments: { action: 'add_node', assetPath: '${captured:btPath}', nodeType: 'Sequence' },
-    expected: 'success',
-    captureResult: { key: 'sequenceId', fromField: 'result.nodeId' } },
-
-  { scenario: 'Build: connect Selector->Sequence', toolName: 'manage_ai',
-    arguments: { action: 'connect_nodes', assetPath: '${captured:btPath}',
-                 parentNodeId: '${captured:rootSelectorId}',
-                 childNodeId: '${captured:sequenceId}' },
-    expected: 'success' },
-
-  { scenario: 'Build: add Wait', toolName: 'manage_ai',
-    arguments: { action: 'add_node', assetPath: '${captured:btPath}', nodeType: 'Wait' },
-    expected: 'success',
-    captureResult: { key: 'waitId', fromField: 'result.nodeId' } },
-
-  { scenario: 'Build: connect Sequence->Wait', toolName: 'manage_ai',
-    arguments: { action: 'connect_nodes', assetPath: '${captured:btPath}',
-                 parentNodeId: '${captured:sequenceId}',
-                 childNodeId: '${captured:waitId}' },
-    expected: 'success' },
-
-  // === Scenario A: root-level Service with FBlackboardKeySelector binding ===
-  { scenario: 'A: add_subnode Service DefaultFocus on Selector',
-    toolName: 'manage_ai',
-    arguments: { action: 'add_subnode', assetPath: '${captured:btPath}',
-                 parentNodeId: '${captured:rootSelectorId}',
-                 subnodeType: 'Service', nodeClass: 'DefaultFocus' },
-    expected: 'success',
-    captureResult: { key: 'serviceId', fromField: 'result.nodeId' },
-    assertions: [
-      { path: 'structuredContent.result.nodeClass', equals: 'BTService_DefaultFocus',
-        label: 'service nodeClass echoed back' }
-    ] },
-
-  { scenario: 'A: set BlackboardKey=TargetActor on service (FBlackboardKeySelector path)',
-    toolName: 'manage_ai',
-    arguments: { action: 'set_node_properties', assetPath: '${captured:btPath}',
-                 nodeId: '${captured:serviceId}',
-                 properties: { BlackboardKey: 'TargetActor' } },
-    expected: 'success' },
-
-  // === Scenario B: stacked decorators on non-root edge ===
-  { scenario: 'B: add_subnode Decorator Blackboard on Sequence',
-    toolName: 'manage_ai',
-    arguments: { action: 'add_subnode', assetPath: '${captured:btPath}',
-                 parentNodeId: '${captured:sequenceId}',
-                 subnodeType: 'Decorator', nodeClass: 'Blackboard' },
-    expected: 'success',
-    captureResult: { key: 'bbDecId', fromField: 'result.nodeId' } },
-
-  { scenario: 'B: set BlackboardKey=Spotted on Blackboard decorator',
-    toolName: 'manage_ai',
-    arguments: { action: 'set_node_properties', assetPath: '${captured:btPath}',
-                 nodeId: '${captured:bbDecId}',
-                 properties: { BlackboardKey: 'Spotted' } },
-    expected: 'success' },
-
-  { scenario: 'B: add_subnode Decorator Cooldown on Sequence (stacking proof)',
-    toolName: 'manage_ai',
-    arguments: { action: 'add_subnode', assetPath: '${captured:btPath}',
-                 parentNodeId: '${captured:sequenceId}',
-                 subnodeType: 'Decorator', nodeClass: 'Cooldown' },
-    expected: 'success' },
-
-  // === Scenario C: root decorator via "root" sentinel ===
-  { scenario: 'C: add_subnode Decorator Cooldown via "root" sentinel',
-    toolName: 'manage_ai',
-    arguments: { action: 'add_subnode', assetPath: '${captured:btPath}',
-                 parentNodeId: 'root',
-                 subnodeType: 'Decorator', nodeClass: 'Cooldown' },
-    expected: 'success' },
-
-  { scenario: 'C: verify runtime BT diagnostics after root sentinel subnode',
-    toolName: 'manage_ai',
-    arguments: { action: 'get_ai_info', behaviorTreePath: '${captured:btPath}' },
-    expected: 'success',
-    assertions: [
-      { path: 'structuredContent.result.aiInfo.assignedBlackboard', equals: bbName,
-        label: 'BT reports the bound BlackboardAsset' },
-      { path: 'structuredContent.result.aiInfo.rootGraphBlackboard', equals: bbName,
-        label: 'BT root graph node reports the bound BlackboardAsset' },
-      { path: 'structuredContent.result.aiInfo.rootGraphBlackboardMatchesAssigned', equals: true,
-        label: 'BT root graph BlackboardAsset matches runtime BT BlackboardAsset' },
-      { path: 'structuredContent.result.aiInfo.rootDecoratorCount', equals: 1,
-        label: 'root decorator count propagated to runtime BT' },
-      { path: 'structuredContent.result.aiInfo.rootDecorators', includesObject: { className: 'BTDecorator_Cooldown' },
-        label: 'runtime root decorators include Cooldown' },
-      { path: 'structuredContent.result.aiInfo.services', includesObject: { className: 'BTService_DefaultFocus', selectedBlackboardKey: 'TargetActor' },
-        label: 'runtime service resolved TargetActor key' },
-      { path: 'structuredContent.result.aiInfo.childDecorators', includesObject: { className: 'BTDecorator_Blackboard', selectedBlackboardKey: 'Spotted' },
-        label: 'runtime child decorator resolved Spotted key' }
-    ] },
-
-  // === Negative: nonexistent GUID -> INVALID_PARENT ===
-  // The error code is INVALID_PARENT; the engine's message reads "Parent node not
-  // found: <guid>". runToolTests matches primary error-type against the message
-  // when present, so we list both alternatives — either side satisfies the matcher.
-  { scenario: 'Negative: nonexistent parentNodeId rejects with INVALID_PARENT',
-    toolName: 'manage_ai',
-    arguments: { action: 'add_subnode', assetPath: '${captured:btPath}',
-                 parentNodeId: '00000000-0000-0000-0000-000000000000',
-                 subnodeType: 'Decorator', nodeClass: 'Cooldown' },
-    expected: 'INVALID_PARENT|not found' },
-
-  // Symmetry with the other 4 BT SubActions: add_subnode also walks
-  // UAIGraphNode::SubNodes via FindGraphNodeByIdOrName, so passing a subnode's
-  // own GUID as parentNodeId now lands on the parent-class validation path and
-  // rejects with INVALID_PARENT_FOR_SUBNODE instead of a misleading "not found"
-  // (caught in cross-model review, F1).
-  { scenario: 'Negative: subnode GUID as parentNodeId rejects with INVALID_PARENT_FOR_SUBNODE',
-    toolName: 'manage_ai',
-    arguments: { action: 'add_subnode', assetPath: '${captured:btPath}',
-                 parentNodeId: '${captured:bbDecId}',
-                 subnodeType: 'Decorator', nodeClass: 'Cooldown' },
-    expected: 'INVALID_PARENT_FOR_SUBNODE|cannot host' },
-
-  // === Cleanup (two-step: assets first, then folder — UE 5.7 folder-delete
-  // modal workaround per reference_mcp_integration_test_patterns memory) ===
-  { scenario: 'Cleanup: delete BT', toolName: 'manage_asset',
-    arguments: { action: 'delete', assetPath: '${captured:btPath}', force: true },
-    expected: 'success|not found' },
-
-  { scenario: 'Cleanup: delete BB', toolName: 'manage_asset',
-    arguments: { action: 'delete', assetPath: '${captured:bbPath}', force: true },
-    expected: 'success|not found' },
-];
-
-await runToolTests('manage_behavior_tree', testCases);