premiere-pro-mcp 1.14.1 → 1.14.2

package/CHANGELOG.md

@@ -6,6 +6,44 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.14.2] - 2026-08-28
+
+### Added
+
+- Added dual-era MCP serving with the stable TypeScript SDK v2: modern
+  `2026-07-28` discovery and stateless request handling over HTTP and stdio,
+  with legacy protocol compatibility through `2025-11-25`.
+- Added validated modern routing headers, cache hints, subscription-listen
+  support, a formal Premiere extension capability, and a machine-readable MCP
+  protocol report in `get_capabilities`.
+- Added an evidence-backed capability matrix covering implemented, SDK-ready,
+  external-boundary, deprecated, and intentionally unsupported MCP surfaces.
+
+### Changed
+
+- Migrated tool, resource, prompt, client, stdio, and Node HTTP integrations
+  from `@modelcontextprotocol/sdk` v1 to the split v2 packages and Standard
+  Schema registration APIs.
+
+### Fixed
+
+- Restored strict JSON Schema 2020-12 tool compatibility and corrected legacy
+  CEP argument contracts, Premiere Time units, Adobe Media Encoder output
+  paths, active-sequence verification, metadata readback, XMP patch merging,
+  and single-extension UXP frame exports.
+- Replaced false-success responses for structural edits, duplicate
+  consolidation, effect copying, nesting, deletion, and other host mutations
+  with verified outcomes or explicit fail-closed errors.
+- Added bounded UXP selection lift and native transition adapters while keeping
+  unavailable track-management and global-redo capabilities explicit.
+
+### Safety
+
+- Live Premiere resources remain private and uncached, and tool discovery is
+  private-cache scoped. The tasks extension and OAuth discovery are not
+  advertised without the durable storage and authorization infrastructure they
+  require.
+
 ## [1.14.1] - 2026-08-27
 
 ### Fixed

package/README.md

@@ -8,11 +8,11 @@
 
 **Give compatible AI assistants structured control over supported Adobe Premiere Pro workflows.**
 
-319 core tools across 37 modules, 14 resources, and 11 guided workflows. A connected UXP host adds 50 capability-gated tools.
+320 core tools across 37 modules, 14 resources, and 11 guided workflows. A connected UXP host adds 54 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)
-[![MCP](https://img.shields.io/badge/MCP-1.29-purple.svg)](https://modelcontextprotocol.io)
+[![MCP](https://img.shields.io/badge/MCP-2026--07--28-purple.svg)](https://modelcontextprotocol.io/specification/2026-07-28)
 [![npm](https://img.shields.io/npm/v/premiere-pro-mcp.svg)](https://www.npmjs.com/package/premiere-pro-mcp)
 [![Fly.io](https://img.shields.io/badge/Fly.io-deployed-7C3AED.svg)](https://premiere-pro-mcp.fly.dev)
 [![Premiere Pro](https://img.shields.io/badge/Premiere%20Pro-2020--2026-9999FF.svg)](https://www.adobe.com/products/premiere.html)
@@ -31,9 +31,9 @@ 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 319 core tools spanning the supported ExtendScript, QE DOM, local media and interchange analysis, revisioned project-context retrieval, safe edit-planning, project-intake preview, review handoff, and connection-verification surfaces. A compatible, authenticated UXP panel adds 50 documented, capability-gated tools without replacing the production CEP bridge.
+The AI handles the entire workflow through 320 core tools spanning the supported ExtendScript, QE DOM, local media and interchange analysis, revisioned project-context retrieval, safe edit-planning, project-intake preview, review handoff, and connection-verification surfaces. A compatible, authenticated UXP panel adds 54 documented, capability-gated tools without replacing the production CEP bridge.
 
-### Latest release: 1.14.1
+### Latest release: 1.14.2
 
 - **Focused discovery:** compatible MCP clients can select essential,
   inspection, delivery, or captions tool packs instead of beginning with the
@@ -47,9 +47,17 @@ The AI handles the entire workflow through 319 core tools spanning the supported
   tarball, keeping the validated distribution path compatible with the current
   npm CLI.
 
-See the [v1.14.1 release notes](https://github.com/leancoderkavy/premiere-pro-mcp/releases/tag/v1.14.1)
+See the [v1.14.2 release notes](https://github.com/leancoderkavy/premiere-pro-mcp/releases/tag/v1.14.2)
 for complete details. Live installation in Premiere Pro still requires host verification.
 
+### Current MCP protocol support
+
+The server uses the stable TypeScript SDK v2 and serves the `2026-07-28`
+stateless protocol over HTTP and stdio, while retaining legacy MCP compatibility
+through `2025-11-25`. Modern clients receive discovery, validated routing headers,
+cache hints, subscription-stream support, and the formal Premiere extension
+capability. See the [complete MCP capability and boundary report](docs/mcp-2026-07-28-capabilities.md).
+
 ---
 
 ## For editors evaluating an AI workflow
@@ -70,15 +78,20 @@ guide](https://premiere-pro-mcp.com/premiere-pro-collaboration-workflow/) before
 you evaluate an MCP path. It links the relevant Adobe guidance, makes no project
 inspection request, and ends with the same read-only connection check.
 
+For a concrete first Project Intake preview, choose one of the three
+[schema-checked, no-sensitive-data starter templates](https://premiere-pro-mcp.com/project-intake/#starter-template).
+They are evaluation samples only: a human policy owner must review and replace
+their bins, media rules, and organization rules before a facility uses one.
+
 ---
 
 ## Quick Start
 
 ### Easiest supported path: Claude Desktop
 
-1. Download the current [Claude Desktop bundle (`.mcpb`)](https://github.com/leancoderkavy/premiere-pro-mcp/releases/download/v1.14.1/premiere-pro-mcp-1.14.1.mcpb).
+1. Download the current [Claude Desktop bundle (`.mcpb`)](https://github.com/leancoderkavy/premiere-pro-mcp/releases/download/v1.14.2/premiere-pro-mcp-1.14.2.mcpb).
 2. In Claude Desktop, open **Settings > Extensions > Advanced settings > Install Extension**, select the downloaded bundle, and restart Claude Desktop.
-3. Download the separate [signed Premiere connector (`.zxp`)](https://github.com/leancoderkavy/premiere-pro-mcp/releases/download/v1.14.1/MCPBridgeCEP.zxp). Open it with your trusted ZXP installer. If your computer has no ZXP installer, use the npm connector installer in **Advanced setup** below.
+3. Download the separate [signed Premiere connector (`.zxp`)](https://github.com/leancoderkavy/premiere-pro-mcp/releases/download/v1.14.2/MCPBridgeCEP.zxp). Open it with your trusted ZXP installer. If your computer has no ZXP installer, use the npm connector installer in **Advanced setup** below.
 4. Restart Premiere, open a project, then open **Window > Extensions > MCP for Adobe Premiere Pro**.
 5. In Claude, enter: `Safely check my Premiere connection with verify_premiere_connection. Make no changes.`
 
@@ -325,11 +338,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.14.1 --install-cep
+npx -y premiere-pro-mcp@1.14.2 --install-cep
 ```
 
 Restart Premiere Pro and start a new Codex session after installation. The plugin
-launches `premiere-pro-mcp@1.14.1` through `npx`; the separate CEP installation is
+launches `premiere-pro-mcp@1.14.2` through `npx`; the separate CEP installation is
 required because the MCP server communicates with the running Premiere host through
 the local bridge.
 
@@ -349,7 +362,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.14.1 --install-cep
+npx -y premiere-pro-mcp@1.14.2 --install-cep
 ```
 
 The Claude Code package lives in
@@ -388,7 +401,7 @@ installed separately.
 QE-backed tools are reported as `experimental` because QE is undocumented and can vary between Premiere builds. Authority availability is reported separately from implementation support, so disabling `edit`, for example, does not incorrectly label editing tools as unsupported. Static metadata never claims that a Premiere operation succeeded; use `ping` and inspect each tool result for runtime evidence.
 
 MCP `tools/list` is filtered to the active authority profile. The default
-`inspect,edit,export,filesystem` profile advertises 317 of the 319 registered
+`inspect,edit,export,filesystem` profile advertises 318 of the 320 registered
 tools and omits `execute_extendscript` and `evaluate_expression`, which require
 explicit `unsafe-script` authority. `ping` and `get_capabilities` remain visible
 under every profile so a restricted or misconfigured server can still explain
@@ -491,7 +504,7 @@ 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 the original 19 UXP tools, 21 consolidated stable workflows, and eight third-wave tools. The first expansion covers effects, deterministic timeline selection, selection batches, scene detection, proxy/ingest, relink, metadata, color conformance, Source Monitor audition, storage, and least-privilege workspace access. The second adds Project-panel selection, marker CRUD, bin organization, sequence settings, imports, typed effect parameters/keyframes, track-item transforms, SequenceEditor timeline edits, sequence lifecycle, and AME encoding. The third wave begins with a redacted event journal, conservative AME terminal receipts, explicit host-readiness gates, safe multi-project sessions, lease-based growing-media control, namespaced workflow checkpoints, bounded media-health maintenance, caption-aware track mute state, and transactional source trim/framing documented in [the third-wave workflow matrix](docs/third-wave-uxp-workflows.md). A separate [hybrid benchmark gate](docs/uxp-hybrid-benchmark.md) keeps native acceleration disabled until reproducible cross-platform evidence exists. See also [the first stable workflow matrix](docs/uxp-stable-workflows.md) and [the next-ten workflow matrix](docs/uxp-next-ten-workflows.md). 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.
+When enabled, MCP discovery includes 54 capability-gated UXP additions. The first expansion covers effects, deterministic timeline selection, selection batches, scene detection, proxy/ingest, relink, metadata, color conformance, Source Monitor audition, storage, and least-privilege workspace access. The second adds Project-panel selection, marker CRUD, bin organization, sequence settings, imports, typed effect parameters/keyframes, track-item transforms, SequenceEditor timeline edits, sequence lifecycle, and AME encoding. The third wave begins with a redacted event journal, conservative AME terminal receipts, explicit host-readiness gates, safe multi-project sessions, lease-based growing-media control, namespaced workflow checkpoints, bounded media-health maintenance, caption-aware track mute state, and transactional source trim/framing documented in [the third-wave workflow matrix](docs/third-wave-uxp-workflows.md). The bounded migration surface also includes a non-ripple selected-item lift plus native video-transition listing and transactions; it does not claim direct empty-track create/delete or global redo support. A separate [hybrid benchmark gate](docs/uxp-hybrid-benchmark.md) keeps native acceleration disabled until reproducible cross-platform evidence exists. See also [the first stable workflow matrix](docs/uxp-stable-workflows.md) and [the next-ten workflow matrix](docs/uxp-next-ten-workflows.md). 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.
 
 The panel now requests access to one operator-selected workspace instead of declaring full filesystem access. Choose the folder in the panel before invoking a path-based UXP workflow. Media, relink, preset, export, and Source Monitor file paths must remain inside it; the persistent capability token and native root path are never returned over MCP. Lexical containment alone cannot exclude symlink, junction, or reparse-point escapes, and Adobe's request-scoped UXP filesystem API does not document canonical-path resolution. Builds without a host-supplied canonical resolver therefore advertise path-based UXP commands as unsupported and fail closed at invocation; use the existing CEP fallback for those operations.
 
@@ -566,11 +579,11 @@ The file-based IPC bridge is simple, reliable, and works across macOS and Window
 
 ---
 
-## Tools (319 core total; 317 under the default profile; 367 with a connected UXP bridge)
+## Tools (320 core total; 318 under the default profile; 372 with a connected UXP bridge)
 
 The [complete supported-actions catalog](docs/supported-actions.md) lists every
 registered core tool, the two tools restricted behind explicit `unsafe-script`
-authority, and all 50 authenticated UXP additions with their current action or mode
+authority, and all 54 authenticated UXP additions with their current action or mode
 values. It is generated from the same MCP registration surface returned to clients;
 the tables below are a shorter workflow-oriented overview.
 
@@ -614,8 +627,7 @@ the tables below are a shorter workflow-oriented overview.
 | `ripple_delete` | Remove clip and close gap (QE) |
 | `roll_edit` / `slide_edit` / `slip_edit` | Professional trim modes (QE) |
 | `move_clip_to_track` | Move between tracks (QE) |
-| `reverse_clip` | Reverse direction (QE, host-dependent) |
-| `speed_change` / `set_clip_speed_qe` | Unavailable: Premiere has no supported scripting API for changing clip speed |
+| `reverse_clip` / `speed_change` / `set_clip_speed_qe` | Unavailable: Premiere has no supported scripting API for changing a timeline clip's speed or direction |
 | `split_clip` / `trim_clip` / `move_clip` | Basic edits; trim verifies source points and visible timeline edges |
 | `set_clip_properties` | Opacity, scale, rotation, position (speed requests fail before mutation) |
 | `link_selection` / `unlink_selection` | Link/unlink A/V |
@@ -629,8 +641,8 @@ the tables below are a shorter workflow-oriented overview.
 > to blend adjacent source frames. See [issue #21](https://github.com/leancoderkavy/premiere-pro-mcp/issues/21).
 
 > **Speed, caption, and visual-keyframe boundaries:** Premiere Pro 26.3 exposes no supported
-> scripting setter or Time Remapping component for timeline-clip speed. `speed_change`,
-> `set_clip_speed_qe`, and `set_clip_properties` with `speed` now stop before host mutation;
+> scripting setter or Time Remapping component for timeline-clip speed or direction. `reverse_clip`,
+> `speed_change`, `set_clip_speed_qe`, and `set_clip_properties` with `speed` now stop before host mutation;
 > use the Speed/Duration UI or pre-render retimed media. `add_text_overlay` likewise stops
 > before mutation because a raw-text-to-caption API is not exposed; import an `.srt`/`.vtt`
 > and use `create_caption_track`, or use a MOGRT/PNG overlay. Keyframe and caption-track
@@ -731,7 +743,7 @@ than presenting UI-only operations as available tools.
 | `set_offline` / `has_proxy` / `detach_proxy` | Offline/proxy management |
 | `set_override_frame_rate` | Override FPS |
 | `set_scale_to_frame_size` | Auto-scale to sequence frame |
-| `get_xmp_metadata` / `set_xmp_metadata` | Raw XMP access |
+| `get_xmp_metadata` / `set_xmp_metadata` | Raw XMP access; writes merge a well-formed patch without removing unrelated fields |
 | `get_color_space` | Color space info |
 
 ### Sequence Management (11)
@@ -895,7 +907,7 @@ premiere-pro-mcp/
 ├── src/
 │   ├── index.ts                 # Entry point — stdio transport setup
 │   ├── http-server.ts           # Entry point — HTTP/SSE transport (Fly.io / remote)
-│   ├── server.ts                # MCP server — registers 319 tools, filtered by authority profile
+│   ├── server.ts                # MCP server — registers 320 tools, filtered by authority profile
 │   ├── bridge/
 │   │   ├── file-bridge.ts       # File-based IPC (write .jsx, poll .json)
 │   │   └── script-builder.ts    # ExtendScript generator with ES3 helpers

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.14.1" ExtensionBundleName="MCP for Adobe Premiere Pro">
+<ExtensionManifest Version="7.0" ExtensionBundleId="com.mcp.premiere.bridge" ExtensionBundleVersion="1.14.2" ExtensionBundleName="MCP for Adobe Premiere Pro">
   <ExtensionList>
-    <Extension Id="com.mcp.premiere.bridge.panel" Version="1.14.1"/>
-    <Extension Id="com.mcp.premiere.bridge.headless" Version="1.14.1"/>
+    <Extension Id="com.mcp.premiere.bridge.panel" Version="1.14.2"/>
+    <Extension Id="com.mcp.premiere.bridge.headless" Version="1.14.2"/>
   </ExtensionList>
   <ExecutionEnvironment>
     <HostList>

package/cep-plugin/index.html

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

package/cep-plugin/main.js

@@ -8,6 +8,8 @@ var pollInterval = null;
 var commandCount = 0;
 var tempDir = "";
 var POLL_MS = 200;
+var HEARTBEAT_MS = 1000;
+var heartbeatInterval = null;
 
 // ---- Logging ----
 function log(msg, cls) {
@@ -157,6 +159,36 @@ function deleteFile(filePath) {
   } catch (e) {}
 }
 
+// The heartbeat carries only protocol state. It is published by rename so a
+// server never observes partial JSON, and an older server can ignore it.
+function writeBridgeHeartbeat() {
+  if (!tempDir) return;
+  var heartbeatPath = path.join(tempDir, "bridge-heartbeat.json");
+  var stagedPath = heartbeatPath + "." + ENGINE_ID + ".staged";
+  try {
+    fs.writeFileSync(stagedPath, JSON.stringify({
+      protocolVersion: 1,
+      state: bridgeRunning ? "running" : "waiting"
+    }), "utf-8");
+    fs.renameSync(stagedPath, heartbeatPath);
+  } catch (e) {
+    deleteFile(stagedPath);
+  }
+}
+
+function startBridgeHeartbeat() {
+  if (heartbeatInterval) clearInterval(heartbeatInterval);
+  writeBridgeHeartbeat();
+  heartbeatInterval = setInterval(writeBridgeHeartbeat, HEARTBEAT_MS);
+}
+
+function stopBridgeHeartbeat() {
+  if (heartbeatInterval) clearInterval(heartbeatInterval);
+  heartbeatInterval = null;
+  // Keep the last heartbeat in place. Its age lets newer servers diagnose a
+  // stopped connector, while concurrent visible/headless panels stay isolated.
+}
+
 // ---- Script Execution ----
 function executeScript(script, callback) {
   // Script is already wrapped in an IIFE by the MCP server's buildScript(),
@@ -264,6 +296,7 @@ function startBridge() {
 
   ensureDir(tempDir);
   bridgeRunning = true;
+  startBridgeHeartbeat();
   setStatus("waiting", "Connector running");
   log("Connector started and ready for safe checks.", "ok");
 
@@ -279,6 +312,8 @@ function startBridge() {
 
 function stopBridge() {
   bridgeRunning = false;
+  writeBridgeHeartbeat();
+  stopBridgeHeartbeat();
   if (pollInterval) clearInterval(pollInterval);
   pollInterval = null;
 
@@ -438,6 +473,7 @@ function handleUpdateClick() {
   // one to click Start, and macOS periodically purges the temp dir — so create it
   // rather than gating auto-start on its existence.
   ensureDir(tempDir);
+  startBridgeHeartbeat();
   log("Auto-starting bridge...");
   setTimeout(startBridge, 500);
   setTimeout(checkForUpdates, 1200);

package/cep-plugin/updater.cjs

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

package/dist/bridge/file-bridge.d.ts

@@ -1,13 +1,33 @@
+export declare const BRIDGE_HEARTBEAT_FILE = "bridge-heartbeat.json";
+export declare const BRIDGE_HEARTBEAT_STALE_MS = 3000;
 export interface BridgeOptions {
     tempDir?: string;
     timeoutMs?: number;
+    /**
+     * Reject a health-style command without publishing it when a current CEP
+     * connector explicitly reports that it is waiting or its heartbeat is stale.
+     * A missing heartbeat remains compatible with older installed connectors.
+     */
+    failFastOnUnreadyHeartbeat?: boolean;
 }
 export interface CommandResult {
     success: boolean;
     data?: unknown;
     error?: string;
 }
+export type BridgeLivenessState = "running" | "waiting" | "stale" | "unknown";
+export interface BridgeLiveness {
+    state: BridgeLivenessState;
+    ageMs: number | null;
+}
 export declare function getTempDir(options?: BridgeOptions): string;
+/**
+ * Inspect the CEP panel's small, content-free heartbeat. This never creates a
+ * directory or reads command, response, project, or media data. Unknown is
+ * intentionally non-fatal so a server upgrade stays compatible with older CEP
+ * panels that do not publish a heartbeat yet.
+ */
+export declare function getBridgeLiveness(options?: BridgeOptions, nowMs?: number): BridgeLiveness;
 /**
  * Send a command (ExtendScript) to the CEP plugin and wait for a response.
  *

package/dist/bridge/file-bridge.js

@@ -6,6 +6,8 @@ import { getHelpersSource, helpersFileName, buildBootstrap } from "./script-buil
 const DEFAULT_TEMP_DIR = join(tmpdir(), "premiere-mcp-bridge");
 const POLL_FALLBACK_MS = 250;
 const DEFAULT_TIMEOUT_MS = 30000;
+export const BRIDGE_HEARTBEAT_FILE = "bridge-heartbeat.json";
+export const BRIDGE_HEARTBEAT_STALE_MS = 3_000;
 /**
  * Create the bridge temp dir private to this user, and — critically — refuse to trust
  * one we didn't create.
@@ -44,6 +46,47 @@ function ensureDir(dir) {
 export function getTempDir(options) {
     return options?.tempDir || process.env.PREMIERE_TEMP_DIR || DEFAULT_TEMP_DIR;
 }
+/**
+ * Inspect the CEP panel's small, content-free heartbeat. This never creates a
+ * directory or reads command, response, project, or media data. Unknown is
+ * intentionally non-fatal so a server upgrade stays compatible with older CEP
+ * panels that do not publish a heartbeat yet.
+ */
+export function getBridgeLiveness(options, nowMs = Date.now()) {
+    const heartbeatPath = join(getTempDir(options), BRIDGE_HEARTBEAT_FILE);
+    try {
+        if (!existsSync(heartbeatPath))
+            return { state: "unknown", ageMs: null };
+        const raw = readFileSync(heartbeatPath, "utf-8");
+        const heartbeat = JSON.parse(raw);
+        if (heartbeat.protocolVersion !== 1 ||
+            (heartbeat.state !== "running" && heartbeat.state !== "waiting")) {
+            return { state: "unknown", ageMs: null };
+        }
+        const ageMs = Math.max(0, nowMs - statSync(heartbeatPath).mtimeMs);
+        return ageMs > BRIDGE_HEARTBEAT_STALE_MS
+            ? { state: "stale", ageMs }
+            : { state: heartbeat.state, ageMs };
+    }
+    catch {
+        return { state: "unknown", ageMs: null };
+    }
+}
+function heartbeatFailure(liveness) {
+    if (liveness.state === "waiting") {
+        return {
+            success: false,
+            error: "The CEP connector is open but not running. In Premiere Pro, open Window > Extensions > MCP Bridge, wait for it to finish starting, then retry once.",
+        };
+    }
+    if (liveness.state === "stale") {
+        return {
+            success: false,
+            error: "The CEP connector heartbeat is stale. Reopen Window > Extensions > MCP Bridge in Premiere Pro, dismiss any blocking dialog, and retry once after it reports running.",
+        };
+    }
+    return null;
+}
 /**
  * Make sure this server version's helpers file exists in the temp dir, and return
  * the bootstrap line each command must carry so the CEP-side engine loads it once.
@@ -68,6 +111,11 @@ export async function sendCommand(script, options) {
     const tempDir = getTempDir(options);
     const timeoutMs = options?.timeoutMs || DEFAULT_TIMEOUT_MS;
     ensureDir(tempDir);
+    if (options?.failFastOnUnreadyHeartbeat) {
+        const failure = heartbeatFailure(getBridgeLiveness(options));
+        if (failure)
+            return failure;
+    }
     const id = randomUUID();
     const cmdFile = join(tempDir, `cmd_${id}.jsx`);
     const stagedCmdFile = `${cmdFile}.staged`;
@@ -118,6 +166,11 @@ export async function sendRawCommand(script, options) {
     const tempDir = getTempDir(options);
     const timeoutMs = options?.timeoutMs || DEFAULT_TIMEOUT_MS;
     ensureDir(tempDir);
+    if (options?.failFastOnUnreadyHeartbeat) {
+        const failure = heartbeatFailure(getBridgeLiveness(options));
+        if (failure)
+            return failure;
+    }
     const id = randomUUID();
     const cmdFile = join(tempDir, `cmd_${id}.jsx`);
     const stagedCmdFile = `${cmdFile}.staged`;

package/dist/bridge/script-builder.js

@@ -62,20 +62,45 @@ function __pad(n) {
 
 function __findSequence(idOrName) {
   var project = app.project;
+  var wantedId = String(idOrName);
   for (var i = 0; i < project.sequences.numSequences; i++) {
     var seq = project.sequences[i];
-    if (seq.sequenceID === idOrName || seq.name === idOrName) {
+    if (String(seq.sequenceID) === wantedId || seq.name === idOrName) {
       return seq;
     }
   }
   return null;
 }
 
+// Premiere can retain a reference to the last active sequence immediately after
+// app.newProject() switches to a new, empty project. Never expose or mutate
+// through that stale object: only a sequence currently enumerated by this
+// project's SequenceCollection is a valid active sequence for this command.
+function __isCurrentProjectSequence(sequence) {
+  if (!sequence || !app || !app.project || !app.project.sequences) return false;
+  var wantedId = "";
+  try { wantedId = String(sequence.sequenceID); } catch (e) { return false; }
+  for (var i = 0; i < app.project.sequences.numSequences; i++) {
+    var candidate = app.project.sequences[i];
+    try {
+      if (candidate === sequence || String(candidate.sequenceID) === wantedId) return true;
+    } catch (e) {}
+  }
+  return false;
+}
+
+function __getCurrentActiveSequence() {
+  var sequence = null;
+  try { sequence = app.project.activeSequence; } catch (e) { return null; }
+  return __isCurrentProjectSequence(sequence) ? sequence : null;
+}
+
 function __findProjectItem(nodeIdOrName, rootItem) {
   if (!rootItem) rootItem = app.project.rootItem;
+  var wantedId = String(nodeIdOrName);
   for (var i = 0; i < rootItem.children.numItems; i++) {
     var item = rootItem.children[i];
-    if (item.nodeId === nodeIdOrName || item.name === nodeIdOrName) {
+    if (String(item.nodeId) === wantedId || item.name === nodeIdOrName) {
       return item;
     }
     if (item.type === 2) { // Bin
@@ -89,13 +114,14 @@ function __findProjectItem(nodeIdOrName, rootItem) {
 function __findClip(nodeId) {
   var seq = app.project.activeSequence;
   if (!seq) return null;
+  var wantedId = String(nodeId);
 
   // Search video tracks
   for (var t = 0; t < seq.videoTracks.numTracks; t++) {
     var track = seq.videoTracks[t];
     for (var c = 0; c < track.clips.numItems; c++) {
       var clip = track.clips[c];
-      if (clip.nodeId === nodeId) {
+      if (String(clip.nodeId) === wantedId) {
         return { clip: clip, trackIndex: t, clipIndex: c, trackType: "video" };
       }
     }
@@ -106,7 +132,7 @@ function __findClip(nodeId) {
     var track = seq.audioTracks[t];
     for (var c = 0; c < track.clips.numItems; c++) {
       var clip = track.clips[c];
-      if (clip.nodeId === nodeId) {
+      if (String(clip.nodeId) === wantedId) {
         return { clip: clip, trackIndex: t, clipIndex: c, trackType: "audio" };
       }
     }

package/dist/http-server.js

@@ -26,7 +26,8 @@ import fs from "node:fs";
 import path from "node:path";
 import { randomBytes } from "node:crypto";
 import { fileURLToPath } from "node:url";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { toNodeHandler } from "@modelcontextprotocol/node";
+import { createMcpHandler } from "@modelcontextprotocol/server";
 import { createServer } from "./server.js";
 import { cleanupTempDir, getTempDir } from "./bridge/file-bridge.js";
 import { getTelemetry } from "./telemetry.js";
@@ -187,6 +188,12 @@ const bridgeOptions = {
 process.env.PREMIERE_MCP_TRANSPORT = "http";
 const telemetry = getTelemetry();
 const admission = new HttpAdmissionController(admissionSettings);
+const mcpHandler = createMcpHandler(() => createServer(bridgeOptions, { telemetry }), {
+    onerror: (error) => console.error("[premiere-pro-mcp] MCP handler error:", error),
+});
+const handleMcpRequest = toNodeHandler(mcpHandler, {
+    onerror: (error) => console.error("[premiere-pro-mcp] MCP Node adapter error:", error),
+});
 const tempDir = getTempDir(bridgeOptions);
 console.error(`[premiere-pro-mcp] Starting HTTP server on port ${PORT}...`);
 console.error(`[premiere-pro-mcp] Temp directory: ${tempDir}`);
@@ -282,18 +289,11 @@ const httpServer = http.createServer(async (req, res) => {
         outcome: "authorized",
         method: req.method ?? "unknown",
     });
-    const mcpServer = createServer(bridgeOptions, { telemetry });
-    const transport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: undefined, // stateless
-    });
     res.on("close", () => {
         admissionDecision.release();
-        transport.close().catch(() => { });
-        mcpServer.close().catch(() => { });
     });
     try {
-        await mcpServer.connect(transport);
-        await transport.handleRequest(req, res, parsedBody);
+        await handleMcpRequest(req, res, parsedBody);
         telemetry.capture("mcp_request", {
             outcome: res.statusCode >= 400 ? "failed" : "succeeded",
             method: req.method ?? "unknown",
@@ -333,6 +333,7 @@ httpServer.listen(PORT, "0.0.0.0", () => {
 async function shutdown(signal) {
     console.error(`[premiere-pro-mcp] ${signal} received, shutting down...`);
     httpServer.close();
+    await mcpHandler.close();
     await telemetry.shutdown();
     process.exit(0);
 }

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
 import { createServer } from "./server.js";
 import { cleanupTempDir, getTempDir } from "./bridge/file-bridge.js";
 import { getTelemetry } from "./telemetry.js";
@@ -21,7 +21,7 @@ function debugLog(message) {
 const args = process.argv.slice(2);
 if (args.includes("--help") || args.includes("-h")) {
     console.log(`
-premiere-pro-mcp — MCP server for Adobe Premiere Pro (317 default-profile tools)
+premiere-pro-mcp — MCP server for Adobe Premiere Pro (318 default-profile tools)
 
 Usage:
   premiere-pro-mcp              Start the MCP server (stdio transport)
@@ -143,14 +143,14 @@ async function main() {
         const address = uxpBridge.address();
         debugLog(`UXP bridge listening on ws://${address.host}:${address.port}${address.path}`);
     }
-    const server = createServer(bridgeOptions, { uxpBridge, telemetry });
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
+    const serverHandle = serveStdio(() => createServer(bridgeOptions, { uxpBridge, telemetry }), {
+        onerror: (error) => console.error("[premiere-pro-mcp] MCP stdio error:", error),
+    });
     debugLog("Server connected and ready");
     const shutdown = async () => {
         if (uxpBridge)
             await uxpBridge.stop();
-        await server.close();
+        await serverHandle.close();
         await telemetry.shutdown();
     };
     process.once("SIGINT", () => void shutdown().finally(() => process.exit(0)));

package/dist/platform-capabilities.d.ts

@@ -57,6 +57,60 @@ export declare function buildPlatformCapabilityReport(capabilities: CapabilityCo
     };
     toolPacks?: ToolPackReport | undefined;
     schemaVersion: number;
+    mcp: {
+        sdk: {
+            generation: number;
+            packages: string[];
+        };
+        protocol: {
+            modernRevision: string;
+            legacyRevisions: string;
+            dualEra: boolean;
+        };
+        features: {
+            statelessRequests: string;
+            serverDiscovery: string;
+            requestMetadataEnvelope: string;
+            headerBasedRouting: string;
+            deterministicCacheableLists: string;
+            resultTypeDiscriminator: string;
+            cancellation: string;
+            progressNotifications: string;
+            traceContext: string;
+            jsonSchema202012: string;
+            cursorPagination: string;
+            resourceTemplates: string;
+            completions: string;
+            embeddedResourcesAndLinks: string;
+            multiRoundTripRequests: string;
+            subscriptionsListen: string;
+            extensionCapabilities: string;
+            tasksExtension: string;
+            mcpAppsExtension: string;
+            skillsOverMcp: string;
+            serverCard: string;
+            oauthClientMetadataDocuments: string;
+            deprecatedSamplingRootsLogging: string;
+        };
+        cachePolicy: {
+            toolsList: {
+                ttlMs: number;
+                cacheScope: string;
+            };
+            promptsList: {
+                ttlMs: number;
+                cacheScope: string;
+            };
+            resourcesList: {
+                ttlMs: number;
+                cacheScope: string;
+            };
+            resourcesRead: {
+                ttlMs: number;
+                cacheScope: string;
+            };
+        };
+    };
     runtime: {
         platform: NodeJS.Platform;
         platformName: string;