premiere-pro-mcp 1.5.0 → 1.6.0

package/CHANGELOG.md

@@ -6,6 +6,30 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.6.0] - 2026-07-31
+
+### Added
+
+- Added a capability-aware UXP foundation for revisioned project inspection, verified saves,
+  preset-based sequence creation, OTIO/FCP XML interchange, transcript-language discovery,
+  Object Mask detection, and Adobe Media Encoder controls on compatible Premiere hosts.
+- Added explicit UXP operation outcomes and bounded operation-ID replay protection so a client retry
+  does not repeat a completed command within the same panel session.
+
+### Changed
+
+- Documented the 10 UXP MCP tools that become available when an authenticated local panel is
+  connected, including their host-version and live-verification boundaries.
+- Updated the MCP SDK and Node type dependencies and GitHub Actions artifact actions.
+
+### Fixed
+
+- `create_project` now rejects directory paths and verifies that Premiere switched to the exact
+  requested `.prproj` path before reporting success, preventing edits from continuing in a
+  previously open project after a failed creation attempt.
+- Claude Desktop bundle packaging now invokes npm through the active Node executable so the
+  release build works on Windows where `npm` is exposed as a command shim.
+
 ## [1.5.0] - 2026-07-30
 
 ### Added

package/README.md

@@ -6,7 +6,7 @@
 
 **Give AI full control over Adobe Premiere Pro.**
 
-279 tools across 31 modules, 3 resources, and 4 guided workflows.
+279 core tools across 31 modules, 3 resources, and 4 guided workflows. A connected UXP host adds 10 capability-gated tools.
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![Node.js](https://img.shields.io/badge/Node.js-20.19%2B-green.svg)](https://nodejs.org)
@@ -27,18 +27,14 @@ An [MCP (Model Context Protocol)](https://modelcontextprotocol.io) server that l
 "Add the B-roll clips to V2, apply a cross dissolve between each, color correct them to match the A-roll, and export a 1080p ProRes."
 ```
 
-The AI handles the entire workflow through 279 tools spanning the supported ExtendScript, QE DOM, local media analysis, and safe edit-planning surfaces.
+The AI handles the entire workflow through 279 core tools spanning the supported ExtendScript, QE DOM, local media analysis, and safe edit-planning surfaces. A compatible, authenticated UXP panel adds 10 documented, capability-gated workflows without replacing the production CEP bridge.
 
-### What's new in 1.3.1
+### What's new in 1.6.0
 
-- Windows npm releases now include a verified, signed CEP ZXP and install it automatically, covering
-  hosts that reject the raw development bundle even when `PlayerDebugMode` is enabled.
-- `set_sequence_frame_rate` now converts frames per second to Premiere ticks per frame and verifies
-  the applied setting instead of assigning a numeric frame period.
-- `premiere-pro-mcp --diagnose-cep` checks the installed manifest, debug-key types, and recent
-  Premiere signature failures.
-- TypeScript 7, Vitest 4, Zod 4, MCP SDK 1.29, Next.js 16.2, and patched transitive dependencies
-  modernize the toolchain and remove production audit findings.
+- **Capability-aware UXP foundation:** compatible Premiere 25.6-26.3 hosts can expose revisioned project inspection, verified saves, preset sequence creation, OTIO/FCP XML interchange, transcript-language discovery, Object Mask detection, and Adobe Media Encoder controls.
+- **Retry-safe UXP mutations:** optional operation IDs prevent a client retry from repeating a completed command in the same panel session, while each command reports `verified` or `committed_unverified` evidence honestly.
+- **Safe project creation:** `create_project` rejects directory paths and verifies Premiere opened the requested `.prproj` before reporting success.
+- **Current distribution metadata:** the CEP/UXP panels, Codex and Claude plugins, landing page, and npm package now all identify v1.6.0.
 
 ### Added in 1.2.0
 
@@ -252,11 +248,11 @@ From a clone of this repository:
 ```bash
 codex plugin marketplace add .
 codex plugin add premiere-pro@premiere-pro-mcp
-npx -y premiere-pro-mcp@1.3.1 --install-cep
+npx -y premiere-pro-mcp@1.6.0 --install-cep
 ```
 
 Restart Premiere Pro and start a new Codex session after installation. The plugin
-launches `premiere-pro-mcp@1.3.1` through `npx`; the separate CEP installation is
+launches `premiere-pro-mcp@1.6.0` through `npx`; the separate CEP installation is
 required because the MCP server communicates with the running Premiere host through
 the local bridge.
 
@@ -276,7 +272,7 @@ For Claude Code, add this repository as a marketplace and install the plugin:
 Then install the Premiere bridge and start a new Claude Code session:
 
 ```bash
-npx -y premiere-pro-mcp@1.3.1 --install-cep
+npx -y premiere-pro-mcp@1.6.0 --install-cep
 ```
 
 The Claude Code package lives in
@@ -366,7 +362,14 @@ PREMIERE_UXP_TOKEN="replace-with-a-long-random-secret" premiere-pro-mcp
 
 Enter the same token in the UXP panel. The listener binds only to `127.0.0.1:7777`, authenticates the WebSocket upgrade, requires a versioned capability handshake, correlates concurrent requests, and fails pending work on timeout or disconnect. Set `PREMIERE_UXP_PORT` to use another loopback port.
 
-When enabled, MCP discovery includes `get_uxp_capabilities`, `get_uxp_state`, and `export_frame_uxp`. A failed UXP command is never silently retried through CEP because the first operation may have partially succeeded.
+When enabled, MCP discovery includes `get_uxp_capabilities`, `get_uxp_state`, `inspect_project_uxp`, `save_project_uxp`, `create_sequence_with_preset_uxp`, `export_interchange_uxp`, `get_transcript_languages_uxp`, `detect_object_masks_uxp`, `configure_encoder_uxp`, and `export_frame_uxp`. Commands are advertised only while the authenticated local UXP bridge is connected; the host capability handshake remains the authority for support in the running Premiere build. A failed UXP command is never silently retried through CEP because the first operation may have partially succeeded.
+
+Premiere 26.2-26.3 hosts also expose documented UXP workflows for revisioned project
+inspection, verified project saves, preset-based sequence creation, OTIO/FCP XML
+interchange, transcript-language discovery, Object Mask detection, and Adobe Media
+Encoder control. Mutations accept optional idempotency keys and return explicit
+verification outcomes. See [the UXP capability foundation](docs/uxp-capability-foundation.md)
+for the command matrix and live-host validation boundary.
 
 ---
 
@@ -410,7 +413,7 @@ The file-based IPC bridge is simple, reliable, and works across macOS and Window
 
 ---
 
-## Tools (279 total; 277 under the default profile)
+## Tools (279 core total; 277 under the default profile; 287 with a connected UXP bridge)
 
 ### Discovery & Inspection (10 + 10)
 

package/cep-plugin/CSXS/manifest.xml

@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<ExtensionManifest Version="7.0" ExtensionBundleId="com.mcp.premiere.bridge" ExtensionBundleVersion="1.5.0" ExtensionBundleName="MCP Bridge">
+<ExtensionManifest Version="7.0" ExtensionBundleId="com.mcp.premiere.bridge" ExtensionBundleVersion="1.6.0" ExtensionBundleName="MCP Bridge">
   <ExtensionList>
-    <Extension Id="com.mcp.premiere.bridge.panel" Version="1.5.0"/>
-    <Extension Id="com.mcp.premiere.bridge.headless" Version="1.5.0"/>
+    <Extension Id="com.mcp.premiere.bridge.panel" Version="1.6.0"/>
+    <Extension Id="com.mcp.premiere.bridge.headless" Version="1.6.0"/>
   </ExtensionList>
   <ExecutionEnvironment>
     <HostList>

package/cep-plugin/index.html

@@ -65,7 +65,7 @@
     <section class="update-section" aria-live="polite">
       <div class="update-copy">
         <span class="section-label">Connector updates</span>
-        <strong id="updateTitle">Version 1.5.0</strong>
+        <strong id="updateTitle">Version 1.6.0</strong>
         <span id="updateDetail">Checking for updates…</span>
       </div>
       <button id="btnUpdate" class="button button-update" onclick="handleUpdateClick()" type="button" disabled>

package/cep-plugin/updater.cjs

@@ -7,7 +7,7 @@
 })(this, function () {
   "use strict";
 
-  var CURRENT_VERSION = "1.5.0";
+  var CURRENT_VERSION = "1.6.0";
   var LATEST_RELEASE_API =
     "https://api.github.com/repos/leancoderkavy/premiere-pro-mcp/releases/latest";
   var RELEASES_URL =

package/dist/tools/project.js

@@ -126,11 +126,33 @@ export function getProjectTools(bridgeOptions) {
                 required: ["path"],
             },
             handler: async (args) => {
+                const requestedPath = args.path.trim();
+                if (!/\.prproj$/i.test(requestedPath)) {
+                    return {
+                        success: false,
+                        error: "create_project path must be a full .prproj file path; Premiere cannot create a project from a directory path.",
+                    };
+                }
                 const script = buildToolScript(`
-          app.newProject("${escapeForExtendScript(args.path)}");
+          var requestedPath = "${escapeForExtendScript(requestedPath)}";
+          function __normalizedProjectPath(path) {
+            return String(path || "").replace(/\\\\/g, "/").toLowerCase();
+          }
+          var beforePath = app.project ? String(app.project.path || "") : "";
+          if (__normalizedProjectPath(beforePath) === __normalizedProjectPath(requestedPath)) {
+            return __error("A project is already open at " + requestedPath + "; choose a new .prproj file path instead.");
+          }
+          app.newProject(requestedPath);
           var project = app.project;
-          if (!project) return __error("Failed to create project");
-          return __result({ created: true, name: project.name, path: project.path });
+          var actualPath = project ? String(project.path || "") : "";
+          if (!project || !actualPath || __normalizedProjectPath(actualPath) !== __normalizedProjectPath(requestedPath)) {
+            return __error(
+              "Premiere did not create a project at " + requestedPath +
+              "; the active project is still " + (actualPath || beforePath || "unavailable") +
+              ". Check that the path is a new .prproj file and its parent directory exists."
+            );
+          }
+          return __result({ created: true, name: project.name, path: actualPath });
         `);
                 return sendCommand(script, bridgeOptions);
             },

package/dist/tools/uxp.d.ts

@@ -22,6 +22,203 @@ export declare function getUxpTools(bridge: UxpWebSocketBridge): {
             error: string;
         }>;
     };
+    inspect_project_uxp: {
+        description: string;
+        parameters: {};
+        handler: () => Promise<{
+            success: boolean;
+            data: {
+                backend: string;
+                result: unknown;
+            };
+        } | {
+            success: boolean;
+            error: string;
+        }>;
+    };
+    save_project_uxp: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                operation_id: {
+                    type: "string";
+                    description: string;
+                };
+            };
+        };
+        handler: (args: {
+            operation_id?: string;
+        }) => Promise<{
+            success: boolean;
+            data: {
+                backend: string;
+                result: unknown;
+            };
+        } | {
+            success: boolean;
+            error: string;
+        }>;
+    };
+    create_sequence_with_preset_uxp: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                name: {
+                    type: string;
+                    description: string;
+                };
+                preset_path: {
+                    type: string;
+                    description: string;
+                };
+                operation_id: {
+                    type: "string";
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            name: string;
+            preset_path: string;
+            operation_id?: string;
+        }) => Promise<{
+            success: boolean;
+            data: {
+                backend: string;
+                result: unknown;
+            };
+        } | {
+            success: boolean;
+            error: string;
+        }>;
+    };
+    export_interchange_uxp: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                format: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                output_file_path: {
+                    type: string;
+                    description: string;
+                };
+                suppress_ui: {
+                    type: string;
+                    description: string;
+                };
+                operation_id: {
+                    type: "string";
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            format: "otio" | "fcpxml";
+            output_file_path: string;
+            suppress_ui?: boolean;
+            operation_id?: string;
+        }) => Promise<{
+            success: boolean;
+            data: {
+                backend: string;
+                result: unknown;
+            };
+        } | {
+            success: boolean;
+            error: string;
+        }>;
+    };
+    get_transcript_languages_uxp: {
+        description: string;
+        parameters: {};
+        handler: () => Promise<{
+            success: boolean;
+            data: {
+                backend: string;
+                result: unknown;
+            };
+        } | {
+            success: boolean;
+            error: string;
+        }>;
+    };
+    detect_object_masks_uxp: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                scope: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+            };
+        };
+        handler: (args: {
+            scope?: "sequence" | "project";
+        }) => Promise<{
+            success: boolean;
+            data: {
+                backend: string;
+                result: unknown;
+            };
+        } | {
+            success: boolean;
+            error: string;
+        }>;
+    };
+    configure_encoder_uxp: {
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                launch: {
+                    type: string;
+                    description: string;
+                };
+                embedded_xmp: {
+                    type: string;
+                    description: string;
+                };
+                sidecar_xmp: {
+                    type: string;
+                    description: string;
+                };
+                start_batch: {
+                    type: string;
+                    description: string;
+                };
+                operation_id: {
+                    type: "string";
+                    description: string;
+                };
+            };
+        };
+        handler: (args: {
+            launch?: boolean;
+            embedded_xmp?: boolean;
+            sidecar_xmp?: boolean;
+            start_batch?: boolean;
+            operation_id?: string;
+        }) => Promise<{
+            success: boolean;
+            data: {
+                backend: string;
+                result: unknown;
+            };
+        } | {
+            success: boolean;
+            error: string;
+        }>;
+    };
     export_frame_uxp: {
         description: string;
         parameters: {

package/dist/tools/uxp.js

@@ -7,6 +7,10 @@ function invoke(bridge, command, args = {}) {
     }));
 }
 export function getUxpTools(bridge) {
+    const operationId = {
+        type: "string",
+        description: "Optional idempotency key (1-128 letters, numbers, dot, underscore, colon, or dash).",
+    };
     return {
         get_uxp_capabilities: {
             description: "Report the authenticated local UXP bridge connection and the capabilities advertised by the connected Premiere host.",
@@ -18,6 +22,88 @@ export function getUxpTools(bridge) {
             parameters: {},
             handler: async () => invoke(bridge, "state.get"),
         },
+        inspect_project_uxp: {
+            description: "Read a compact, revisioned project and sequence snapshot through documented Premiere UXP APIs.",
+            parameters: {},
+            handler: async () => invoke(bridge, "project.snapshot"),
+        },
+        save_project_uxp: {
+            description: "Save the active project through UXP and require Premiere to confirm success.",
+            parameters: {
+                type: "object",
+                properties: { operation_id: operationId },
+            },
+            handler: async (args) => invoke(bridge, "project.save", {
+                ...(args.operation_id ? { operationId: args.operation_id } : {}),
+            }),
+        },
+        create_sequence_with_preset_uxp: {
+            description: "Create and verify a sequence from a preset path using the documented Premiere 26.3+ UXP API.",
+            parameters: {
+                type: "object",
+                properties: {
+                    name: { type: "string", description: "New sequence name." },
+                    preset_path: { type: "string", description: "Local Premiere sequence preset path." },
+                    operation_id: operationId,
+                },
+                required: ["name", "preset_path"],
+            },
+            handler: async (args) => invoke(bridge, "sequence.createPreset", {
+                name: args.name, presetPath: args.preset_path,
+                ...(args.operation_id ? { operationId: args.operation_id } : {}),
+            }),
+        },
+        export_interchange_uxp: {
+            description: "Export the active sequence as OpenTimelineIO or Final Cut Pro XML with explicit verification.",
+            parameters: {
+                type: "object",
+                properties: {
+                    format: { type: "string", enum: ["otio", "fcpxml"], description: "Interchange format." },
+                    output_file_path: { type: "string", description: "Absolute output file path." },
+                    suppress_ui: { type: "boolean", description: "Suppress Premiere export UI; defaults to true." },
+                    operation_id: operationId,
+                },
+                required: ["format", "output_file_path"],
+            },
+            handler: async (args) => invoke(bridge, "interchange.export", {
+                format: args.format, outputFilePath: args.output_file_path,
+                ...(args.suppress_ui === undefined ? {} : { suppressUI: args.suppress_ui }),
+                ...(args.operation_id ? { operationId: args.operation_id } : {}),
+            }),
+        },
+        get_transcript_languages_uxp: {
+            description: "List transcription languages supported by the connected Premiere 26.3+ host.",
+            parameters: {},
+            handler: async () => invoke(bridge, "transcript.languages"),
+        },
+        detect_object_masks_uxp: {
+            description: "Detect whether the active project or sequence contains an Object Mask using Premiere 26.3+.",
+            parameters: {
+                type: "object",
+                properties: { scope: { type: "string", enum: ["sequence", "project"], description: "Inspection scope; defaults to sequence." } },
+            },
+            handler: async (args) => invoke(bridge, "objectMask.has", args.scope ? { scope: args.scope } : {}),
+        },
+        configure_encoder_uxp: {
+            description: "Launch or configure Adobe Media Encoder and optionally start its queued batch using Premiere 26.3+.",
+            parameters: {
+                type: "object",
+                properties: {
+                    launch: { type: "boolean", description: "Launch AME if needed." },
+                    embedded_xmp: { type: "boolean", description: "Enable or disable embedded XMP." },
+                    sidecar_xmp: { type: "boolean", description: "Enable or disable sidecar XMP." },
+                    start_batch: { type: "boolean", description: "Start queued AME encodes." },
+                    operation_id: operationId,
+                },
+            },
+            handler: async (args) => invoke(bridge, "encoder.configure", {
+                ...(args.launch === undefined ? {} : { launch: args.launch }),
+                ...(args.embedded_xmp === undefined ? {} : { embeddedXmp: args.embedded_xmp }),
+                ...(args.sidecar_xmp === undefined ? {} : { sidecarXmp: args.sidecar_xmp }),
+                ...(args.start_batch === undefined ? {} : { startBatch: args.start_batch }),
+                ...(args.operation_id ? { operationId: args.operation_id } : {}),
+            }),
+        },
         export_frame_uxp: {
             description: "Export a sequence frame through Premiere's supported UXP Exporter and verify the output file in the host panel.",
             parameters: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "premiere-pro-mcp",
-  "version": "1.5.0",
-  "description": "Adobe Premiere Pro MCP server with 279 AI video editing tools for timeline automation, effects, media management, and export.",
+  "version": "1.6.0",
+  "description": "Adobe Premiere Pro MCP server with 279 core AI video editing tools and a capability-aware UXP bridge for supported Premiere workflows.",
   "main": "dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",
@@ -75,13 +75,13 @@
     "node": ">=20.19.0"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "posthog-node": "^5.46.1",
     "ws": "^8.21.1",
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@types/node": "^26.1.1",
+    "@types/node": "^26.1.2",
     "@types/ws": "^8.18.1",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10"

package/scripts/build-claude-desktop.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import { cp, copyFile, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
 import { spawn } from "node:child_process";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -22,6 +23,22 @@ const run = (command, args, cwd) =>
     });
   });
 
+function runNpm(args, cwd) {
+  // On Windows, spawn("npm", ...) can fail because npm is exposed as npm.cmd
+  // rather than an executable. Running npm's bundled CLI through this Node
+  // process works on every supported platform and keeps shell execution off.
+  const npmCli = path.join(
+    path.dirname(process.execPath),
+    "node_modules",
+    "npm",
+    "bin",
+    "npm-cli.js",
+  );
+  return existsSync(npmCli)
+    ? run(process.execPath, [npmCli, ...args], cwd)
+    : run("npm", args, cwd);
+}
+
 await rm(stage, { recursive: true, force: true });
 await mkdir(path.join(stage, "server"), { recursive: true });
 await mkdir(artifacts, { recursive: true });
@@ -49,7 +66,7 @@ await writeFile(
   )}\n`,
 );
 
-await run("npm", ["ci", "--omit=dev", "--ignore-scripts"], stage);
+await runNpm(["ci", "--omit=dev", "--ignore-scripts"], stage);
 
 const mcpbPath = path.join(
   artifacts,
@@ -60,9 +77,8 @@ const dxtPath = path.join(
   `premiere-pro-mcp-${packageJson.version}.dxt`,
 );
 
-await run(
-  "npx",
-  ["-y", "@anthropic-ai/mcpb@2.1.2", "pack", stage, mcpbPath],
+await runNpm(
+  ["exec", "--yes", "@anthropic-ai/mcpb@2.1.2", "pack", stage, mcpbPath],
   root,
 );
 await copyFile(mcpbPath, dxtPath);

package/uxp-plugin/commands.cjs

@@ -7,10 +7,18 @@
 
   function createCommandRegistry(deps) {
     const ppro = deps.ppro, Protocol = deps.Protocol;
+    const completedOperations = new Map();
     const definitions = {
       "capabilities.get": { readOnly: true, handler: capabilities },
       "state.get": { readOnly: true, handler: stateSnapshot },
-      "frame.export": { probe: canExportFrame, handler: exportFrame },
+      "project.snapshot": { readOnly: true, minHostVersion: "25.6.0", probe: canInspectProject, handler: projectSnapshot },
+      "project.save": { idempotent: true, minHostVersion: "25.6.0", probe: canSaveProject, handler: saveProject },
+      "sequence.createPreset": { destructive: true, undoable: false, minHostVersion: "26.3.0", probe: canCreatePresetSequence, handler: createPresetSequence },
+      "interchange.export": { minHostVersion: "26.2.0", probe: canExportInterchange, handler: exportInterchange },
+      "transcript.languages": { readOnly: true, minHostVersion: "26.3.0", probe: canQueryTranscriptLanguages, handler: transcriptLanguages },
+      "objectMask.has": { readOnly: true, minHostVersion: "26.3.0", probe: canInspectObjectMasks, handler: hasObjectMask },
+      "encoder.configure": { minHostVersion: "26.3.0", probe: canConfigureEncoder, handler: configureEncoder },
+      "frame.export": { minHostVersion: "25.6.0", probe: canExportFrame, handler: exportFrame },
       "transition.video.list": { readOnly: true, minHostVersion: "25.6.0", probe: canListTransitions, handler: listTransitions },
       "transition.video.add": { destructive: true, undoable: true, minHostVersion: "25.6.0", probe: canMutateTransitions, handler: addTransition },
       "transition.video.remove": { destructive: true, undoable: true, minHostVersion: "25.6.0", probe: canMutateTransitions, handler: removeTransition }
@@ -19,19 +27,39 @@
     async function dispatch(command, args) {
       const definition = definitions[command];
       if (!definition) throw commandError("UXP_UNSUPPORTED_COMMAND", "Unsupported UXP command: " + command);
-      if (definition.probe && !definition.probe()) throw commandError("UXP_COMMAND_UNAVAILABLE", command + " is not supported by this Premiere build");
-      return definition.handler(args || {});
+      if (definition.probe && !await definition.probe()) throw commandError("UXP_COMMAND_UNAVAILABLE", command + " is not supported by this Premiere build");
+      const input = args || {};
+      const operationId = validateOperationId(input.operationId);
+      const operationKey = operationId ? command + ":" + operationId : null;
+      if (!definition.readOnly && operationKey && completedOperations.has(operationKey)) {
+        return { ...completedOperations.get(operationKey), replayed: true };
+      }
+      const result = await definition.handler(input);
+      const envelope = definition.readOnly ? result : {
+        operationId: operationId || null,
+        outcome: result && result.outcome ? result.outcome : "verified",
+        ...result
+      };
+      if (!definition.readOnly && operationKey) {
+        completedOperations.set(operationKey, envelope);
+        if (completedOperations.size > 256) completedOperations.delete(completedOperations.keys().next().value);
+      }
+      return envelope;
     }
     async function capabilities() {
       let project = null, sequence = null;
       try { project = await ppro.Project.getActiveProject(); sequence = project && await project.getActiveSequence(); } catch (_) {}
       const commands = {};
-      Object.keys(definitions).forEach((name) => {
-        const definition = definitions[name], supported = !definition.probe || definition.probe();
-        commands[name] = { supported, readOnly: !!definition.readOnly, destructive: !!definition.destructive, undoable: !!definition.undoable };
+      for (const name of Object.keys(definitions)) {
+        const definition = definitions[name], supported = !definition.probe || await definition.probe();
+        commands[name] = {
+          supported, backend: "uxp", documented: true,
+          readOnly: !!definition.readOnly, destructive: !!definition.destructive,
+          undoable: !!definition.undoable, idempotent: !!definition.idempotent
+        };
         if (definition.minHostVersion) commands[name].minHostVersion = definition.minHostVersion;
         if (!supported) commands[name].reason = "Required Premiere UXP API is unavailable in this host";
-      });
+      }
       return {
         backend: "uxp", protocolVersion: Protocol.PROTOCOL_VERSION, hostMinVersion: "25.6.0",
         activeProject: !!project, activeSequence: !!sequence, commands,
@@ -44,6 +72,73 @@
       const position = sequence && await sequence.getPlayerPosition();
       return { projectOpen: !!project, sequenceOpen: !!sequence, playheadSeconds: position ? position.seconds : null };
     }
+    async function projectSnapshot() {
+      const project = await ppro.Project.getActiveProject();
+      if (!project) return { revision: "no-project", project: null, sequences: [] };
+      const sequences = Array.from(await project.getSequences() || []).map((sequence) => ({
+        guid: String(sequence.guid || ""), name: String(sequence.name || "")
+      }));
+      const active = await project.getActiveSequence();
+      const revision = simpleRevision([project.guid, project.name, project.path, active && active.guid, sequences.map((item) => item.guid).join(",")].join("|"));
+      return {
+        revision,
+        project: { guid: String(project.guid || ""), name: String(project.name || ""), path: String(project.path || "") },
+        activeSequenceGuid: active ? String(active.guid || "") : null,
+        sequences
+      };
+    }
+    async function saveProject() {
+      const project = await ppro.Project.getActiveProject();
+      if (!project) throw commandError("UXP_NO_ACTIVE_PROJECT", "No active project");
+      const saved = await project.save();
+      if (!saved) throw commandError("UXP_VERIFICATION_FAILED", "Premiere did not confirm the project save");
+      return { saved: true, outcome: "verified", projectGuid: String(project.guid || "") };
+    }
+    async function createPresetSequence(args) {
+      assertOnlyKeys(args, ["name", "presetPath", "operationId"]);
+      const name = requiredString(args.name, "name"), presetPath = requiredString(args.presetPath, "presetPath");
+      const project = await ppro.Project.getActiveProject();
+      if (!project) throw commandError("UXP_NO_ACTIVE_PROJECT", "No active project");
+      const sequence = await project.createSequenceWithPresetPath(name, presetPath);
+      if (!sequence) throw commandError("UXP_VERIFICATION_FAILED", "Premiere did not return the created sequence");
+      const verified = Array.from(await project.getSequences() || []).some((item) => String(item.guid || "") === String(sequence.guid || ""));
+      if (!verified) throw commandError("UXP_VERIFICATION_FAILED", "Created sequence was not present in the project");
+      return { created: true, outcome: "verified", sequence: { guid: String(sequence.guid || ""), name: String(sequence.name || name) } };
+    }
+    async function exportInterchange(args) {
+      assertOnlyKeys(args, ["format", "outputFilePath", "suppressUI", "operationId"]);
+      const format = requiredString(args.format, "format"), outputFilePath = requiredString(args.outputFilePath, "outputFilePath");
+      if (format !== "otio" && format !== "fcpxml") throw commandError("UXP_INVALID_ARGUMENT", "format must be otio or fcpxml");
+      const context = await activeContext(false);
+      const method = format === "otio" ? "exportAsOpenTimelineIO" : "exportAsFinalCutProXML";
+      const exported = await ppro.ProjectConverter[method](context.sequence, outputFilePath, args.suppressUI !== false);
+      if (!exported) throw commandError("UXP_VERIFICATION_FAILED", "Premiere did not confirm the interchange export");
+      return { exported: true, outcome: "verified", format, outputFilePath };
+    }
+    async function transcriptLanguages() {
+      const languages = Array.from(await ppro.Transcript.querySupportedLanguages() || []);
+      return { languages, count: languages.length };
+    }
+    async function hasObjectMask(args) {
+      assertOnlyKeys(args, ["scope"]);
+      const scope = args.scope == null ? "sequence" : args.scope;
+      if (scope !== "sequence" && scope !== "project") throw commandError("UXP_INVALID_ARGUMENT", "scope must be sequence or project");
+      const project = await ppro.Project.getActiveProject();
+      if (!project) throw commandError("UXP_NO_ACTIVE_PROJECT", "No active project");
+      const target = scope === "project" ? project : await project.getActiveSequence();
+      if (!target) throw commandError("UXP_NO_ACTIVE_SEQUENCE", "No active sequence");
+      return { scope, hasObjectMask: !!ppro.ObjectMaskUtils.hasObjectMask(target) };
+    }
+    async function configureEncoder(args) {
+      assertOnlyKeys(args, ["launch", "embeddedXmp", "sidecarXmp", "startBatch", "operationId"]);
+      const performed = [];
+      if (args.launch) { if (!await ppro.EncoderManager.launchEncoder()) throw commandError("UXP_VERIFICATION_FAILED", "AME did not launch"); performed.push("launch"); }
+      if (args.embeddedXmp != null) { await ppro.EncoderManager.setEmbeddedXMPEnabled(!!args.embeddedXmp); performed.push("embeddedXmp"); }
+      if (args.sidecarXmp != null) { await ppro.EncoderManager.setSidecarXMPEnabled(!!args.sidecarXmp); performed.push("sidecarXmp"); }
+      if (args.startBatch) { if (!await ppro.EncoderManager.startBatchEncode()) throw commandError("UXP_VERIFICATION_FAILED", "AME batch queue did not start"); performed.push("startBatch"); }
+      if (!performed.length) throw commandError("UXP_INVALID_ARGUMENT", "At least one encoder operation is required");
+      return { configured: true, outcome: "committed_unverified", performed };
+    }
     async function tickTime(seconds, name) {
       const value = Number(seconds);
       if (!Number.isFinite(value) || value < 0) throw commandError("UXP_INVALID_ARGUMENT", name + " must be a non-negative number");
@@ -119,6 +214,24 @@
       if (!committed) throw commandError("UXP_TRANSACTION_FAILED", "Premiere did not commit the transition transaction");
     }
     function canExportFrame() { return !!(ppro.Exporter && typeof ppro.Exporter.exportSequenceFrame === "function"); }
+    function canInspectProject() { return !!(ppro.Project && typeof ppro.Project.getActiveProject === "function"); }
+    async function activeProjectHas(name) {
+      if (!canInspectProject()) return false;
+      const project = await ppro.Project.getActiveProject();
+      return !project || typeof project[name] === "function";
+    }
+    function canSaveProject() { return activeProjectHas("save"); }
+    function canCreatePresetSequence() { return activeProjectHas("createSequenceWithPresetPath"); }
+    function canExportInterchange() {
+      return !!(ppro.ProjectConverter && typeof ppro.ProjectConverter.exportAsOpenTimelineIO === "function" &&
+        typeof ppro.ProjectConverter.exportAsFinalCutProXML === "function");
+    }
+    function canQueryTranscriptLanguages() { return !!(ppro.Transcript && typeof ppro.Transcript.querySupportedLanguages === "function"); }
+    function canInspectObjectMasks() { return !!(ppro.ObjectMaskUtils && typeof ppro.ObjectMaskUtils.hasObjectMask === "function"); }
+    function canConfigureEncoder() {
+      return !!(ppro.EncoderManager && typeof ppro.EncoderManager.launchEncoder === "function" &&
+        typeof ppro.EncoderManager.startBatchEncode === "function");
+    }
     function canListTransitions() { return !!(ppro.TransitionFactory && typeof ppro.TransitionFactory.getVideoTransitionMatchNames === "function"); }
     function canMutateTransitions() {
       return canListTransitions() && typeof ppro.TransitionFactory.createVideoTransition === "function" &&
@@ -129,7 +242,7 @@
 
   function validateAddArgs(args) {
     assertObject(args);
-    assertOnlyKeys(args, ["videoTrackIndex", "clipIndex", "matchName", "position", "durationSeconds", "forceSingleSided", "transitionAlignment"]);
+    assertOnlyKeys(args, ["videoTrackIndex", "clipIndex", "matchName", "position", "durationSeconds", "forceSingleSided", "transitionAlignment", "operationId"]);
     const result = targetArgs(args);
     if (typeof args.matchName !== "string" || !args.matchName.trim() || args.matchName.length > 256) throw commandError("UXP_INVALID_ARGUMENT", "matchName must be a non-empty string of at most 256 characters");
     result.matchName = args.matchName; result.position = optionalPosition(args.position);
@@ -145,7 +258,7 @@
     return result;
   }
   function validateRemoveArgs(args) {
-    assertObject(args); assertOnlyKeys(args, ["videoTrackIndex", "clipIndex", "position"]);
+    assertObject(args); assertOnlyKeys(args, ["videoTrackIndex", "clipIndex", "position", "operationId"]);
     const result = targetArgs(args); result.position = optionalPosition(args.position); return result;
   }
   function targetArgs(args) { return { videoTrackIndex: nonNegativeInt(args.videoTrackIndex, "videoTrackIndex"), clipIndex: nonNegativeInt(args.clipIndex, "clipIndex") }; }
@@ -155,6 +268,9 @@
   function nonNegativeInt(value, name) { if (!Number.isInteger(value) || value < 0) throw commandError("UXP_INVALID_ARGUMENT", name + " must be a non-negative integer"); return value; }
   function positiveNumber(value, name) { const number = Number(value); if (!Number.isFinite(number) || number <= 0) throw commandError("UXP_INVALID_ARGUMENT", name + " must be positive"); return number; }
   function positiveInt(value, fallback, name) { return Math.round(positiveNumber(value == null ? fallback : value, name)); }
+  function requiredString(value, name) { if (typeof value !== "string" || !value.trim() || value.length > 4096) throw commandError("UXP_INVALID_ARGUMENT", name + " must be a non-empty string"); return value; }
+  function validateOperationId(value) { if (value == null) return null; if (typeof value !== "string" || !/^[A-Za-z0-9._:-]{1,128}$/.test(value)) throw commandError("UXP_INVALID_ARGUMENT", "operationId must be 1-128 safe characters"); return value; }
+  function simpleRevision(value) { var hash = 2166136261; for (var i = 0; i < value.length; i += 1) { hash ^= value.charCodeAt(i); hash = Math.imul(hash, 16777619); } return "uxp-" + (hash >>> 0).toString(16); }
   function commandError(code, message) { const error = new Error(message); error.code = code; return error; }
   return { createCommandRegistry, validateAddArgs, validateRemoveArgs, commandError };
 });

package/uxp-plugin/manifest.json

@@ -2,7 +2,7 @@
   "manifestVersion": 5,
   "id": "com.ppmcp.premiere.uxp",
   "name": "Premiere Pro MCP Bridge",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "main": "index.html",
   "host": { "app": "premierepro", "minVersion": "25.6.0" },
   "entrypoints": [