unreal-engine-mcp-server 0.6.0-beta-e → 0.6.0

package/dist/tools/catalog/capabilities/records/system-control/system-ops.js

@@ -1,523 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-const PT = 'system_control';
-export const SYSTEM_OPS_RECORDS = [
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'run_ubt',
-        domain: 'build',
-        family: 'build',
-        summary: 'Run UnrealBuildTool for a target/platform/configuration, spawning UBT locally with a manage_pipeline bridge fallback.',
-        whenToUse: ['The project must be built via UnrealBuildTool.'],
-        whenNotToUse: ['Only a console command or CVar is needed.'],
-        inputProps: {
-            target: { type: 'string', description: 'UBT target name (required).' },
-            platform: { type: 'string', description: 'Platform (default Win64).' },
-            configuration: { type: 'string', description: 'Build configuration (default Development).' },
-            arguments: { type: 'string', description: 'Extra UBT arguments (validated).' },
-        },
-        required: ['target'],
-        effect: 'write',
-        behavior: { longRunning: true },
-        costLatency: 'long-running',
-        costResources: 'high',
-        dispatchAction: 'manage_pipeline',
-        exampleInput: { action: 'run_ubt', target: 'MyProject', platform: 'Win64', configuration: 'Development' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'package_project',
-        domain: 'build',
-        family: 'build',
-        aliases: ['system_control.cook_maps'],
-        topics: ['package project', 'packaging the game', 'build game', 'maps to cook', 'shipping build'],
-        summary: 'Start a project package (cook, stage, pak, archive) and return a jobId to poll; the build runs asynchronously in the editor.',
-        whenToUse: ['A cooked, staged, archived build of the project is needed.'],
-        whenNotToUse: ['Only a code target must be compiled (use run_ubt).', 'The result of an already-started package is wanted (use package_status).'],
-        inputProps: {
-            platform: { type: 'string', description: 'Target platform (default Win64): Win64, Mac, Linux, LinuxArm64, Android, IOS.' },
-            configuration: { type: 'string', description: 'Client configuration (default Development): Debug, DebugGame, Development, Test, Shipping.' },
-            archiveDirectory: { type: 'string', description: 'Where the archived build lands (default <Project>/Packaged).' },
-            maps: { type: 'array', items: { type: 'string', description: 'A /Game map package path.' }, description: 'Maps to cook. Pass these when a map is reached by NAME at runtime (OpenLevel) rather than by reference, or the cooker will not find it.' },
-            pak: { type: 'boolean', description: 'Pak the staged content (default true).' },
-            build: { type: 'boolean', description: 'Compile the game target first (default true).' },
-        },
-        outputProps: {
-            jobId: { type: 'string', description: 'Pass to package_status. Jobs live in the editor session and do not survive a restart.' },
-            status: { type: 'string', description: 'Always "running" here: the call returns as soon as UAT is launched.' },
-            archiveDirectory: { type: 'string', description: 'Resolved absolute archive directory.' },
-            commandLine: { type: 'string', description: 'The exact UAT command line that was launched.' },
-            platform: { type: 'string', description: 'Resolved target platform.' },
-            configuration: { type: 'string', description: 'Resolved client configuration.' },
-        },
-        required: [],
-        effect: 'write',
-        behavior: { longRunning: true },
-        costLatency: 'long-running',
-        costResources: 'high',
-        dispatchAction: 'system_control',
-        exampleInput: { action: 'package_project', platform: 'Win64', configuration: 'Development', maps: ['/Game/Maps/L_Hub'] },
-        exampleOutput: { success: true, jobId: '0F1E2D3C-4B5A-6978-8796-A5B4C3D2E1F0', status: 'running', archiveDirectory: 'D:/Proj/Packaged', commandLine: '-ScriptsForProject=... BuildCookRun ...', platform: 'Win64', configuration: 'Development' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'package_status',
-        domain: 'build',
-        family: 'build',
-        topics: ['package status', 'packaging progress', 'build progress', 'is the package done'],
-        summary: 'Report a job started by package_project or launch_build: running, succeeded or failed, with elapsed time and logs; a launch_build job adds the game log tail and its error count.',
-        whenToUse: ['A package started by package_project must be checked for completion.', 'A packaged-build smoke run started by launch_build must be checked.'],
-        whenNotToUse: ['A new package should be started (use package_project).'],
-        inputProps: {
-            jobId: { type: 'string', description: 'The jobId package_project or launch_build returned. Omit to list the jobIds this editor session knows.' },
-        },
-        outputProps: {
-            jobId: { type: 'string', description: 'Echoed job identifier.' },
-            jobIds: { type: 'array', items: { type: 'string', description: 'A known jobId.' }, description: 'Every job this editor session started; returned when jobId is omitted.' },
-            status: { type: 'string', description: 'running, succeeded or failed.' },
-            uatResult: { type: 'string', description: "UAT's own result word once the task finished." },
-            elapsedSeconds: { type: 'number', description: 'Seconds so far while running, total runtime once finished.' },
-            archiveDirectory: { type: 'string', description: 'Where the archived build lands.' },
-            commandLine: { type: 'string', description: 'The UAT command line this job launched.' },
-            logDirectory: { type: 'string', description: 'Where to read the failure: a failed pack leaves nothing in the archive directory.' },
-            platform: { type: 'string', description: 'Target platform of the job.' },
-            configuration: { type: 'string', description: 'Client configuration of the job.' },
-            gameLogPath: { type: 'string', description: 'launch_build only: where the packaged game wrote its log.' },
-            exitCode: { type: 'number', description: 'launch_build only: the exit code of a game that quit before its run ended.' },
-            errorCount: { type: 'number', description: 'launch_build only: log lines reporting an Error or a fatal error.' },
-            logTail: { type: 'array', items: { type: 'string' }, description: 'launch_build only: the last 30 lines of the game log.' },
-            mapsLoaded: { type: 'array', items: { type: 'string' }, description: 'launch_build only: every map the game logged a LoadMap for, in order; empty means it never reached a level.' },
-        },
-        required: [],
-        effect: 'read',
-        dispatchAction: 'system_control',
-        exampleInput: { action: 'package_status', jobId: '0F1E2D3C-4B5A-6978-8796-A5B4C3D2E1F0' },
-        exampleOutput: { success: true, jobId: '0F1E2D3C-4B5A-6978-8796-A5B4C3D2E1F0', status: 'succeeded', uatResult: 'Completed', elapsedSeconds: 401.2, archiveDirectory: 'D:/Proj/Packaged', commandLine: '-ScriptsForProject=... BuildCookRun ...', logDirectory: 'D:/Proj/Saved/Logs', platform: 'Win64', configuration: 'Development' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'launch_build',
-        domain: 'build',
-        family: 'build',
-        topics: ['run packaged game', 'launch build', 'smoke test build', 'test packaged build', 'does the build run'],
-        summary: 'Start the packaged Win64 game of this project for a short smoke run (offscreen by default), close it after the run, and return a jobId to poll with package_status.',
-        whenToUse: ['A packaged build must be shown to start and keep running, not just to have packaged.'],
-        whenNotToUse: ['No build has been packaged yet (use package_project first).', 'The game should be tested inside the editor (use control_editor.play).'],
-        inputProps: {
-            archiveDirectory: { type: 'string', description: 'Archive directory package_project wrote (default <Project>/Packaged). Must be inside the project.' },
-            seconds: { type: 'number', description: 'How long the game runs before it is closed (default 20, 5-120). Quitting or crashing sooner fails the run.' },
-            windowed: { type: 'boolean', description: 'Show a 1280x720 window instead of rendering offscreen (default false: no window, no focus taken).' },
-        },
-        outputProps: {
-            jobId: { type: 'string', description: 'Pass to package_status.' },
-            status: { type: 'string', description: 'Always "running" here: the call returns once the game has started.' },
-            executable: { type: 'string', description: 'The packaged game executable that was started.' },
-            gameLogPath: { type: 'string', description: 'Where the game writes its log.' },
-            seconds: { type: 'number', description: 'Length of the run in seconds.' },
-        },
-        required: [],
-        effect: 'write',
-        costLatency: 'interactive',
-        costResources: 'medium',
-        dispatchAction: 'system_control',
-        exampleInput: { action: 'launch_build', seconds: 20 },
-        exampleOutput: { success: true, jobId: '1A2B3C4D-5E6F-7081-92A3-B4C5D6E7F809', status: 'running', executable: 'D:/Proj/Packaged/Windows/Proj/Binaries/Win64/Proj.exe', gameLogPath: 'D:/Proj/Saved/Logs/McpBuildRun.log', seconds: 20 },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'run_tests',
-        domain: 'build',
-        family: 'build',
-        topics: ['automation tests', 'run tests', 'test suite', 'functional tests', 'test results'],
-        summary: 'Run automation tests in the editor, one after another, and answer with each one\'s result: passed or not, its duration, and the errors and warnings it reported.',
-        whenToUse: ['The project automation tests must be executed and their results read.'],
-        whenNotToUse: ['A single ad-hoc console command is needed.', 'Play In Editor is running: the automation framework starts no test while a game runs (stop it first).'],
-        inputProps: {
-            filter: { type: 'string', description: 'Run the tests whose full path contains this, ignoring case (System.Core.Math, Project.MyGame). Omitted, every test is a match, capped by maxTests. Functional tests (Project.Functional Tests.<map>.<test>) open their map in the editor.' },
-            maxTests: { type: 'number', description: 'Run at most this many of the matching tests, in the order the editor lists them (default 50, at most 200); matched says how many there were.' },
-            timeoutSeconds: { type: 'number', description: 'Stop a test still running after this many seconds and count it failed (default 60, at most 600).' },
-        },
-        required: [],
-        outputProps: {
-            tests: {
-                type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-                description: 'One row per test run: name (its full path), passed, durationSeconds, errorCount and errors, warningCount and warnings (the first 10 of each), and a note when it timed out or was not run.',
-            },
-            matched: { type: 'number', description: 'Tests matching the filter, run or not.' },
-            passed: { type: 'number', description: 'Tests that passed.' },
-            failed: { type: 'number', description: 'Tests that failed or timed out.' },
-            notRun: { type: 'number', description: 'Tests the framework did not start (another run or Play In Editor began meanwhile).' },
-            allPassed: { type: 'boolean', description: 'True when at least one test ran and every test passed.' },
-        },
-        outputRequired: ['tests', 'matched', 'passed', 'failed', 'allPassed'],
-        effect: 'write',
-        behavior: { longRunning: true },
-        costLatency: 'long-running',
-        costResources: 'medium',
-        dispatchAction: 'manage_tests',
-        exampleInput: { action: 'run_tests', filter: 'System.Core.Math.Vector', maxTests: 10 },
-        exampleOutput: {
-            success: true,
-            message: 'Ran 1 of 1 matching test(s): 1 passed, 0 failed',
-            tests: [{ name: 'System.Core.Math.Vector Normalization', passed: true, durationSeconds: 0.002 }],
-            matched: 1,
-            passed: 1,
-            failed: 0,
-            allPassed: true,
-        },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'subscribe',
-        domain: 'logs',
-        family: 'logs',
-        summary: 'Subscribe this connection to the live editor log stream (every category; filter on the client, or use read_log for a filtered one-shot read).',
-        whenToUse: ['New editor log lines must be streamed as they arrive.'],
-        whenNotToUse: ['A one-shot historical log read is needed.'],
-        inputProps: {},
-        required: [],
-        effect: 'write',
-        dispatchAction: 'manage_logs',
-        exampleInput: { action: 'subscribe' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'unsubscribe',
-        domain: 'logs',
-        family: 'logs',
-        summary: 'Stop streaming the live editor log to this connection.',
-        whenToUse: ['A log subscription made with subscribe must end.'],
-        whenNotToUse: ['No subscription is active.'],
-        inputProps: {},
-        required: [],
-        effect: 'write',
-        dispatchAction: 'manage_logs',
-        exampleInput: { action: 'unsubscribe' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'read_log',
-        domain: 'logs',
-        family: 'logs',
-        topics: ['compile errors', 'build output', 'previous run', 'editor output', 'check for errors', 'show errors', 'see game messages', 'what did the game print'],
-        summary: 'Read the newest editor log lines (kept since editor start), filtered by text, category or minimum severity, or read the build (UnrealBuildTool), Live Coding or previous-run log instead; returns the lines and a match count.',
-        whenToUse: [
-            'A one-shot historical log read is needed: Live Coding or compile results, PIE warnings such as Accessed None, or the output of a console command that only logs (au.DumpActiveSounds).',
-        ],
-        whenNotToUse: ['New lines must be streamed as they arrive (use subscribe).'],
-        inputProps: {
-            lines: { type: 'number', description: 'How many of the newest matching lines to return, oldest first (default 100, max 1000).' },
-            filter: { type: 'string', description: 'Case-insensitive plain text (not a regex) a line must contain; separate alternatives with | to match any of them (LoadMap|Bringing World).' },
-            category: { type: 'string', description: 'Only lines of this log category, e.g. LogBlueprintUserMessages. Editor source only; refused with the other sources.' },
-            minVerbosity: {
-                type: 'string',
-                enum: ['error', 'warning', 'display', 'log', 'verbose'],
-                description: 'Least severe level to include (default log): error returns errors only, warning adds warnings, verbose returns everything. Editor source only; refused with the other sources.',
-            },
-            source: {
-                type: 'string',
-                enum: ['editor', 'livecoding', 'build', 'previous'],
-                description: 'editor (default): the editor log. build: the UnrealBuildTool log of the last compile, where the compiler errors behind "Live coding failed" go. livecoding: the Live Coding console log (patching and linking). previous: the log of the editor\'s previous run, e.g. why an editor that went away exited. Only filter and lines apply to build, livecoding and previous.',
-            },
-            runsBack: { type: 'number', description: 'With source previous: how many editor runs back to read (default 1, max 20). After a crash and one more restart, the crashed run is 2.' },
-        },
-        required: [],
-        outputProps: {
-            lines: { type: 'array', items: { type: 'string' }, description: 'Matching lines as "[seconds since start] Category: Verbosity: message", oldest first.' },
-            returned: { type: 'number', description: 'How many lines were returned.' },
-            matched: { type: 'number', description: 'How many buffered lines matched; more than returned means the lines cap cut the oldest.' },
-            logFile: { type: 'string', description: 'For build, livecoding and previous: the file read. A previous run\'s name carries its start time.' },
-        },
-        effect: 'read',
-        dispatchAction: 'manage_logs',
-        exampleInput: { action: 'read_log', lines: 50, minVerbosity: 'warning' },
-        exampleOutput: {
-            success: true,
-            message: 'Read 1 of 1 matching log line(s).',
-            lines: ['[812.402] LogScript: Warning: Accessed None trying to read property Music'],
-            returned: 1,
-            matched: 1,
-        },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'list_output_files',
-        domain: 'logs',
-        family: 'output-files',
-        topics: ['list screenshots', 'screenshot files', 'snapshot files', 'output files'],
-        summary: 'List the files the MCP itself wrote: screenshots (Saved/Screenshots) and environment snapshots (Saved/unreal-mcp, tmp/unreal-mcp, temp/unreal-mcp).',
-        whenToUse: ['Screenshots or snapshots taken during a task must be found or cleaned up.'],
-        whenNotToUse: ['Project assets are wanted (use manage_asset list or query_asset).'],
-        inputProps: {
-            limit: { type: 'integer', minimum: 1, maximum: 500, description: 'How many files to return (default 100, max 500).' },
-            offset: { type: 'integer', minimum: 0, description: 'How many of the newest matching files to skip (default 0); pass the previous reply\'s nextOffset to read the next page.' },
-            root: { type: 'string', enum: ['Saved/Screenshots', 'Saved/unreal-mcp', 'tmp/unreal-mcp', 'temp/unreal-mcp'], description: 'Search only this output folder (default all four).' },
-            extension: { type: 'string', description: 'Only files with this extension, e.g. png or json (a leading dot is ignored, case-insensitive).' },
-        },
-        required: [],
-        outputProps: {
-            files: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Each file: path (project-relative, what delete_output_file takes), sizeBytes, modified (ISO 8601). Newest first.' },
-            total: { type: 'number', description: 'How many files match the root and extension filters, across all pages.' },
-            returned: { type: 'number', description: 'How many files this page lists.' },
-            offset: { type: 'number', description: 'The offset this page starts at.' },
-            hasMore: { type: 'boolean', description: 'True when more matching files follow this page.' },
-            nextOffset: { type: 'number', description: 'The offset of the next page; present only when hasMore is true.' },
-            roots: { type: 'string', description: 'The folders searched.' },
-        },
-        effect: 'read',
-        exampleInput: { action: 'list_output_files', root: 'Saved/Screenshots', extension: 'png', limit: 20 },
-        exampleOutput: { success: true, message: '1 of 1 MCP output file(s), newest first', files: [{ path: 'Saved/Screenshots/check.png', sizeBytes: 193744, modified: '2026-09-27T21:11:05.000Z' }], total: 1, returned: 1, offset: 0, hasMore: false, roots: 'Saved/Screenshots' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'delete_output_file',
-        domain: 'logs',
-        family: 'output-files',
-        topics: ['delete screenshot', 'remove screenshot file', 'delete snapshot file', 'clean up output files'],
-        summary: 'Delete files the MCP wrote (screenshots or environment snapshots), one path or a list of paths; nothing outside Saved/Screenshots, Saved/unreal-mcp, tmp/unreal-mcp or temp/unreal-mcp can be reached.',
-        whenToUse: ['A screenshot or snapshot the task created is no longer needed.'],
-        whenNotToUse: ['A project asset must go (use manage_asset delete).', 'The screenshot is not taken yet (pass keepFile: false to screenshot instead).'],
-        inputProps: {
-            path: { type: 'string', description: 'Project-relative file path exactly as list_output_files shows it, e.g. Saved/Screenshots/check.png.' },
-            paths: { type: 'array', minItems: 1, items: { type: 'string' }, description: 'Several project-relative file paths to delete in one call; each gets its own entry in results. Takes precedence over path.' },
-        },
-        required: [],
-        requiredOneOf: ['path', 'paths'],
-        outputProps: {
-            path: { type: 'string', description: 'With path: the file that was deleted.' },
-            deleted: { type: 'boolean', description: 'With path: true when the file is gone.' },
-            existsAfter: { type: 'boolean', description: 'With path: whether the file still exists after the call.' },
-            results: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'With paths: one entry per path (path, deleted, and errorCode plus error when it was not deleted). The call fails with PARTIAL_DELETE when any path was not deleted.' },
-            deletedCount: { type: 'number', description: 'With paths: how many files were deleted.' },
-            failedCount: { type: 'number', description: 'With paths: how many paths were not deleted.' },
-        },
-        effect: 'destructive',
-        exampleInput: { action: 'delete_output_file', path: 'Saved/Screenshots/check.png' },
-        exampleOutput: { success: true, message: 'Deleted Saved/Screenshots/check.png', path: 'Saved/Screenshots/check.png', deleted: true, existsAfter: false },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'list_save_games',
-        domain: 'project',
-        family: 'save-games',
-        topics: ['save game', 'save slot', 'savegame file', 'read save file', 'saved best score'],
-        summary: 'List the game\'s SaveGame slots (Saved/SaveGames), or read one slot as the game loads it: its SaveGame class and every saved property value.',
-        whenToUse: [
-            'What a game saved must be checked, such as a best score or the settings SaveGameToSlot wrote.',
-            'The slots a game created must be found before one is edited or deleted.',
-        ],
-        whenNotToUse: [
-            'The values a running game holds are wanted (inspect.get_property on GameInstance): it keeps what it loaded.',
-            'A slot must change (use edit_save_game).',
-        ],
-        inputProps: {
-            slotName: { type: 'string', description: 'Slot to read, as listed: its file name without .sav. Omit to list every slot.' },
-            userIndex: { type: 'integer', minimum: 0, description: 'User index the game saves under (default 0).' },
-        },
-        required: [],
-        outputProps: {
-            slots: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Without slotName: each slot as {slotName, sizeBytes, modified (ISO 8601)}, newest first.' },
-            count: { type: 'number', description: 'Without slotName: how many slots there are.' },
-            slotName: { type: 'string', description: 'With slotName: the slot read.' },
-            saveGameClass: { type: 'string', description: 'With slotName: class path of the saved SaveGame object.' },
-            properties: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'With slotName: every saved property by name with its value.' },
-        },
-        effect: 'read',
-        exampleInput: { action: 'list_save_games', slotName: 'Profile' },
-        exampleOutput: { success: true, message: 'Read save slot Profile (BP_Save_C)', slotName: 'Profile', saveGameClass: '/Game/Core/BP_Save.BP_Save_C', properties: { BestScore: 26050, MusicVolume: 1 } },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'edit_save_game',
-        domain: 'project',
-        family: 'save-games',
-        topics: ['edit save game', 'reset save file', 'delete save slot', 'write save slot', 'reset best score'],
-        summary: 'Change a SaveGame slot on disk: set saved properties and write it again (a missing slot is created from saveGameClass), or delete the slot.',
-        whenToUse: [
-            'Test runs left values in a save (a best score, unlocks) that must be put back.',
-            'A save must be seeded or removed to test a load, continue or first-run flow.',
-        ],
-        whenNotToUse: [
-            'The slot only needs reading (use list_save_games).',
-            'A running game must change now: it keeps what it loaded, so set the GameInstance value too (inspect.set_property).',
-        ],
-        inputProps: {
-            slotName: { type: 'string', description: 'Slot to change, as list_save_games lists it: its file name without .sav.' },
-            userIndex: { type: 'integer', minimum: 0, description: 'User index the game saves under (default 0).' },
-            properties: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Saved properties to set, by name, each value as list_save_games shows it ({"BestScore": 0}). All are checked before the slot is written. A slot being created may leave them out: it is written with its class defaults.' },
-            saveGameClass: { type: 'string', description: 'SaveGame subclass to create the slot from when it does not exist yet, such as /Game/Core/BP_Save.BP_Save_C (SaveGame itself is abstract); an existing slot keeps its own class.' },
-            deleteSlot: { type: 'boolean', description: 'true deletes the slot instead; properties are then ignored.' },
-        },
-        required: ['slotName'],
-        requiredOneOf: ['properties', 'saveGameClass', 'deleteSlot'],
-        outputProps: {
-            slotName: { type: 'string', description: 'The slot changed.' },
-            saveGameClass: { type: 'string', description: 'Class path of the slot\'s SaveGame object.' },
-            properties: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Every saved property as read back from the written slot.' },
-            created: { type: 'boolean', description: 'True when the slot did not exist and was created from saveGameClass.' },
-            saved: { type: 'boolean', description: 'True when the slot was written.' },
-            deleted: { type: 'boolean', description: 'With deleteSlot: true when the slot is gone.' },
-            existsAfter: { type: 'boolean', description: 'With deleteSlot: whether the slot still exists after the call.' },
-        },
-        effect: 'destructive',
-        exampleInput: { action: 'edit_save_game', slotName: 'Profile', properties: { BestScore: 0 } },
-        exampleOutput: { success: true, message: 'Saved slot Profile', slotName: 'Profile', saveGameClass: '/Game/Core/BP_Save.BP_Save_C', properties: { BestScore: 0, MusicVolume: 1 }, created: false, saved: true },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'spawn_category',
-        domain: 'logs',
-        family: 'logs',
-        summary: 'Turn a Gameplay Debugger category on or off in game (its ActiveInGame setting), adding the category entry when it is missing.',
-        whenToUse: ['A Gameplay Debugger category (AI, BehaviorTree, EQS, Perception, ...) must show or hide in the in-game debugger.'],
-        whenNotToUse: ['Editor log output is wanted (use subscribe or read_log).'],
-        inputProps: {
-            categoryName: { type: 'string', description: 'Category name (letters, digits, underscore, hyphen only).' },
-            category: { type: 'string', description: 'Same as categoryName; categoryName wins when both are given.' },
-            enabled: { type: 'boolean', description: 'Show (true, default) or hide (false) the category in game.' },
-        },
-        required: [],
-        effect: 'write',
-        dispatchAction: 'manage_debug',
-        exampleInput: { action: 'spawn_category', categoryName: 'AI', enabled: true },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'execute_python',
-        domain: 'python',
-        family: 'python',
-        topics: ['python', 'run python', 'python script', 'execute script', 'py code'],
-        summary: 'Execute inline Python code or a .py file in the editor via the native HandleExecutePython handler.',
-        whenToUse: ['Editor-side Python automation must run inline or from a script file.'],
-        whenNotToUse: ['Untrusted code without review; runs arbitrary editor-side code.'],
-        inputProps: {
-            code: { type: 'string', description: 'Python code to execute inline (1 MB max).', maxLength: 1048576 },
-            file: { type: 'string', description: 'Path to a .py file to execute.', maxLength: 4096 },
-        },
-        outputProps: {
-            output: { type: 'string', description: 'Captured stdout from the script.' },
-            error: { type: 'string', description: 'Captured stderr and the interpreter traceback when the script raises.' },
-            executionId: { type: 'string', description: 'Correlates the run with the temp wrapper under Saved/Temp/MCP_Python.' },
-            codeSha256: { type: 'string', description: 'SHA-256 of the executed code, as logged.' },
-        },
-        required: [],
-        requiredOneOf: ['code', 'file'],
-        effect: 'write',
-        policyOverride: { consent: 'explicit' },
-        behavior: { longRunning: true },
-        costLatency: 'long-running',
-        costResources: 'medium',
-        plugins: ['PythonScriptPlugin'],
-        dispatchAction: 'system_control',
-        exampleInput: { action: 'execute_python', code: 'print("hello")' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'set_project_setting',
-        domain: 'project',
-        family: 'project',
-        summary: 'Set one setting (section and key): applied to the live settings object and saved where the editor itself saves that class, the project Default<Config>.ini for a project setting, the user Saved config for a per-user one (EditorPerProjectUserSettings). configFile names the file written.',
-        whenToUse: ['A single project setting value must be written.'],
-        whenNotToUse: ['The full settings document must be read (use get_project_settings).'],
-        inputProps: {
-            section: { type: 'string', description: 'Settings section: a settings class path such as /Script/EngineSettings.GeneralProjectSettings, or its short name.' },
-            key: { type: 'string', description: 'Setting key.' },
-            value: { type: 'string', description: 'Setting value.' },
-        },
-        required: ['section', 'key'],
-        effect: 'write',
-        costLatency: 'interactive',
-        dispatchAction: 'system_control',
-        exampleInput: { action: 'set_project_setting', section: '/Script/EngineSettings.GeneralProjectSettings', key: 'ProjectName', value: 'MyProject' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'get_project_settings',
-        domain: 'project',
-        family: 'project',
-        topics: ['rendering and physics', 'config section', 'default map', 'ini key'],
-        summary: 'Read project settings: with no section, the engine version, project name and directory, default maps and general settings; with a section or category (rendering, input, physics, audio, packaging...), every config property of it, or one key\'s value.',
-        whenToUse: ['Project settings must be read for a section.'],
-        whenNotToUse: ['A single setting must be written (use set_project_setting).'],
-        inputProps: {
-            key: { type: 'string', description: 'Single config property to read from the section; the reply then carries key and value.' },
-            section: { type: 'string', description: 'Settings section.' },
-            category: { type: 'string', description: 'A section by friendly name instead of section: general, maps, packaging, rendering, input, physics, collision, audio, engine, navigation.' },
-        },
-        required: [],
-        outputProps: {
-            settings: {
-                type: 'object',
-                'x-unreal-reflection-boundary': true,
-                description: 'Config properties of the requested section (every CPF_Config property of the settings class as text; omitted when key names one), or the project snapshot (engineVersion, projectName, projectDir, maps, general) when no section is given.',
-            },
-            section: { type: 'string', description: 'Resolved settings class path.' },
-            configName: { type: 'string', description: 'Config file family (Engine, Game, Input, ...).' },
-            settingCount: { type: 'number', description: 'Number of config properties returned.' },
-            key: { type: 'string', description: 'Requested key, when one was asked for.' },
-            value: { type: 'string', description: 'Value of the requested key.' },
-            hint: { type: 'string', description: 'How to get a full section dump.' },
-        },
-        outputRequired: [],
-        effect: 'read',
-        costLatency: 'interactive',
-        dispatchAction: 'system_control',
-        exampleInput: { action: 'get_project_settings', section: '/Script/EngineSettings.GeneralProjectSettings' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'validate_assets',
-        domain: 'project',
-        family: 'project',
-        topics: ['check they load', 'broken', 'fail to load', 'content folder', 'find broken assets', 'verify assets', 'data validation', 'run validators'],
-        summary: 'Check that assets load without error, and with dataValidation that they pass the project\'s and the engine\'s Data Validation (the editor\'s Validate Assets): each asset path, or every asset under a folder (recursive by default); returns isValid, per-path results and the checked and invalid counts.',
-        whenToUse: ['Asset references must be validated before use.', 'Assets must pass Data Validation (the editor\'s Validate Assets) before they are relied on or shipped.'],
-        whenNotToUse: ['A single asset must be imported or created (use manage_asset).'],
-        inputProps: {
-            paths: { type: 'array', items: { type: 'string' }, description: 'Asset paths to validate.' },
-            assetPath: { type: 'string', description: 'Single asset path to validate.' },
-            path: { type: 'string', description: 'Another single asset or folder path; validated alongside assetPath when both are given.' },
-            recursive: { type: 'boolean', description: 'For a folder path, include its subfolders (default true).' },
-            dataValidation: { type: 'boolean', description: 'Also run Data Validation on every asset that loads (default false): an asset row gains dataValidation (valid, invalid or notValidated, the last when no validator checks that kind of asset) with its errors and warnings, a folder row the count of each verdict and issues (up to 20 assets with errors or warnings). An invalid asset makes its row invalid.' },
-        },
-        required: [],
-        outputProps: {
-            isValid: { type: 'boolean', description: 'True when every path loaded (and, with dataValidation, none was invalid).' },
-            results: {
-                type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-                description: 'One row per path: path, isValid, kind (asset, directory, missing or invalid), message, assetCount for a folder, and with dataValidation its verdict, errors, warnings or issues.',
-            },
-            checkedCount: { type: 'number', description: 'Paths checked.' },
-            invalidCount: { type: 'number', description: 'Paths that failed.' },
-        },
-        outputRequired: ['isValid', 'results'],
-        effect: 'read',
-        costLatency: 'interactive',
-        dispatchAction: 'system_control',
-        exampleInput: { action: 'validate_assets', paths: ['/Game/Materials/M_Base'], dataValidation: true },
-        exampleOutput: {
-            success: true,
-            message: 'Asset validation completed; all assets valid',
-            isValid: true,
-            results: [{ path: '/Game/Materials/M_Base', isValid: true, kind: 'asset', message: 'Asset loaded successfully', dataValidation: 'valid' }],
-            checkedCount: 1,
-            invalidCount: 0,
-        },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'lumen_update_scene',
-        domain: 'render',
-        family: 'render',
-        summary: 'Trigger a Lumen scene update via the manage_render bridge action.',
-        whenToUse: ['Lumen GI must refresh the scene capture.'],
-        whenNotToUse: ['A full lighting build is needed (use build_lighting via build_environment).'],
-        inputProps: {},
-        required: [],
-        effect: 'write',
-        costLatency: 'interactive',
-        costResources: 'medium',
-        dispatchAction: 'manage_render',
-        exampleInput: { action: 'lumen_update_scene' },
-    }),
-];
-//# sourceMappingURL=system-ops.js.map

package/dist/tools/catalog/capabilities/records/system-control/widget-audio-viewport.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-export declare const WIDGET_AUDIO_VIEWPORT_RECORDS: readonly CapabilityRecordSource[];
-//# sourceMappingURL=widget-audio-viewport.d.ts.map