premiere-pro-mcp

What changed

Changed 2026-10-28 12:40 UTC

15 descriptions rewritten, 3 tools added.

--- pinned/add_keyframe
+++ observed/add_keyframe
  {
    "annotations": {
      "destructiveHint": false,
-   "description": "Add and read back a keyframe on an effect property. The receipt warns when its time is outside the clip's visible range. This verifies stored parameter data only; render/playback verification remains host-dependent.",
+   "description": "Add and read back a keyframe on an effect property. The receipt warns when its time is outside the clip's visible range. Two-component numeric values must match the current host value shape; Motion Position and Anchor Point use normalized 0–1 coordinates only. Colour keys refuse because CEP has no lossless time-specific colour setter. This verifies stored parameter data only; render/playback verification remains host-dependent.",
    "inputSchema": {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "additionalProperties": false,
-         "description": "Value at the keyframe",
-         "type": "number"
+         "anyOf": [
+           {
+             "type": "number"
+           },
+           {
+             "items": {
+               "type": "number"
+             },
+             "maxItems": 2,
+             "minItems": 2,
+             "type": "array"
+           },
+           {
+             "items": {
+               "type": "number"
+             },
+             "maxItems": 4,
+             "minItems": 4,
+             "type": "array"
+           }
+         ],
+         "description": "Finite scalar or numeric vector matching the host property shape. Motion Position/Anchor Point require normalized 0–1 pairs. Colour arrays are recognized but refused without a lossless colour-key API.",
+         "type": [
+           "number",
+           "array"
+         ]
        }
      },
      "required": [

--- pinned/add_title
+++ observed/add_title
  {
    "annotations": {
      "destructiveHint": false,
-   "description": "Add an on-screen title from plain text using a stock Essential Graphics template that ships with Premiere (default: Basic Title). Pass text for one line, or lines to fill the template's text fields in order (for example a lower third's name and role). Premiere-built templates (kind 'premiere') get the text baked into a verified copy before import, because Premiere exposes no writable text for them (textVerification 'template_verified'; confirm the render with export_frame). The baked copy path is returned as templateFile and saved under the application support premiere-pro-mcp/titles folder (macOS: ~/Library/Application Support/premiere-pro-mcp/titles). The cache keeps the newest 50 baked copies by modification time; export or copy templates elsewhere if a project needs older copies retained. After Effects-built templates (kind 'after_effects') are imported and their text fields written by position and read back from Premiere (textVerification 'verified', 'mismatch', 'missing_property', or 'committed_unverified'). The graphic is trimmed to duration_seconds and its length read back. Use list_stock_titles to see templates, their kind, and how many lines each takes.",
+   "description": "Add an on-screen title from plain text using a stock Essential Graphics template that ships with Premiere (default: Basic Title). Pass text for one line, or lines to fill the template's text fields in order (for example a lower third's name and role). Premiere-built templates (kind 'premiere') get the text baked into a verified copy before import, because Premiere exposes no writable text for them (textVerification 'template_verified'; confirm the render with export_frame). The baked copy path is returned as templateFile and saved under the application support premiere-pro-mcp/titles folder (macOS: ~/Library/Application Support/premiere-pro-mcp/titles). The cache keeps the newest 50 baked copies by modification time; export or copy templates elsewhere if a project needs older copies retained. After Effects-built templates (kind 'after_effects') are imported and their text fields written by position and read back from Premiere (textVerification 'verified', 'mismatch', 'missing_property', or 'committed_unverified'). The graphic is trimmed to duration_seconds and its length read back. Optional styling: font_family (PostScript name) and font_size write every text run of each AE text control when the template allows font editing (Premiere 26 fontEditValue/fontSizeEditValue runs, or legacy fontName/fontSize keys); fill_color requires one exposed Fill Color control; position moves the whole graphic through intrinsic normalized Motion Position. Each requested field has styleChecks readback. Premiere-authored font/fill styling and align are refused before import: no reliable writable/readable CEP 26.5.2 contract is established. Tracking is unsupported. Font readback confirms the stored name, not installation or rendered glyphs. Use list_stock_titles to see templates, their kind, and how many lines each takes.",
    "inputSchema": {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "additionalProperties": false,
+       "align": {
+         "description": "Alignment request. Currently refused before import because a reliable CEP text-alignment setter/readback contract is unavailable.",
+         "enum": [
+           "left",
+           "center",
+           "right"
+         ],
+         "type": "string"
+       },
        "duration_seconds": {
          "description": "How long the title stays on screen in seconds (default: 5).",
          "type": "number"
+       "fill_color": {
+         "description": "Optional opaque #RRGGBB fill through exactly one exposed MGT Fill Color control; does not guess private JSON color encodings.",
+         "pattern": "^#[0-9a-fA-F]{6}$",
+         "type": "string"
+       },
+       "font_family": {
+         "description": "Optional PostScript font name (for example Metropolis-Regular) for every requested AE text field and every text run in it. Requires a template that allows font editing (Premiere 26 fontEditValue runs, or a legacy fontName key). Stored-name readback does not prove the font is installed or rendered.",
+         "maxLength": 256,
+         "minLength": 1,
+         "type": "string"
+       },
+       "font_size": {
+         "description": "Optional text size in points for every requested AE text field and every text run in it. Requires a template that allows size editing (Premiere 26 fontSizeEditValue runs, or a legacy fontSize key).",
+         "exclusiveMinimum": 0,
+         "maximum": 1000,
+         "type": "number"
+       },
        "idempotency_key": {
          "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
          "maxLength": 128,
+       "position": {
+         "additionalProperties": false,
+         "description": "Optional normalized intrinsic Motion Position of the whole graphic, not its internal text-layer anchor.",
+         "properties": {
+           "x": {
+             "description": "Horizontal normalized sequence position (0–1).",
+             "maximum": 1,
+             "minimum": 0,
+             "type": "number"
+           },
+           "y": {
+             "description": "Vertical normalized sequence position (0–1).",
+             "maximum": 1,
+             "minimum": 0,
+             "type": "number"
+           }
+         },
+         "required": [
+           "x",
+           "y"
+         ],
+         "type": "object"
+       },
        "start_seconds": {
          "description": "Timeline start in seconds (default: 0).",
          "type": "number"

--- pinned/copy_effect_values
+++ observed/copy_effect_values
  {
    "annotations": {
      "destructiveHint": false,
-   "description": "Copy verified scalar and colour effect-property values from one effect to the matching effect on another clip. Both clips must already have the same effect applied. Properties are matched by position, then by unique display name, because effects such as Lumetri Color repeat names across sections. Legacy CEP deliberately refuses Blend Mode because Premiere can corrupt its enum value on cross-clip writes.",
+   "description": "Copy verified scalar, numeric-array and colour effect-property values from one effect to the matching effect on another clip. Both clips must already have the same effect applied. Properties are matched by position, then by unique display name, because effects such as Lumetri Color repeat names across sections. Legacy CEP deliberately refuses Blend Mode because Premiere can corrupt its enum value on cross-clip writes.",
    "inputSchema": {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "additionalProperties": false,

--- pinned/duplicate_clip
+++ observed/duplicate_clip
  {
    "annotations": {
      "destructiveHint": false,
-   "description": "EXPERIMENTAL: Duplicate a timeline clip, with its linked audio/video partner, onto the first tracks above it that are empty for the clip's time range. The copy keeps the clip's source in point and visible duration, is placed with an overwrite edit (nothing ripples), and is read back. A post-write mismatch is committed_unverified; inspect the timeline or use Undo. Fails without changes when no free track is available; add one with add_tracks.",
+   "description": "EXPERIMENTAL: Duplicate a timeline clip, with its linked audio/video partner, onto the first tracks above it that are empty for the clip's time range. The copy keeps the clip's source in point and visible duration, is placed with an overwrite edit (nothing ripples), and is read back. A post-write mismatch is committed_unverified; inspect the timeline or use Undo. High-rate audio above 48 kHz refuses before writing temporary source marks unless its existing marks already match the copy range; native restore diagnostics are pending. Fails without changes when no free track is available; add one with add_tracks.",
    "inputSchema": {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "additionalProperties": false,

--- pinned/get_export_file_extension
+++ observed/get_export_file_extension
  {
    "annotations": {
      "destructiveHint": false,
-   "description": "Get the export file extension from Premiere. If Premiere returns none, infer it only for an existing .epr in a recognized Adobe Media Encoder format folder; that fallback is marked unconfirmed and should be checked before delivery.",
+   "description": "Get the export file extension from Premiere. If Premiere returns none, infer it only for an existing .epr whose real filesystem parent is a recognized Adobe Media Encoder format folder; report that resolved preset path. This fallback is unconfirmed and should be checked before delivery.",
    "inputSchema": {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "additionalProperties": false,
-         "description": "Full path to the export preset file (.epr)",
+         "description": "Absolute path on this server to the export preset file (.epr). Relative paths, NUL bytes and trailing directory separators are refused before host dispatch.",
+         "maxLength": 4096,
+         "minLength": 1,
          "type": "string"
        }
      },

+ tool added: list_extensions

--- pinned/move_clip
+++ observed/move_clip
  {
    "annotations": {
      "destructiveHint": false,
-   "description": "EXPERIMENTAL (undocumented QE DOM for track changes): Move a clip to a new position on the timeline; optional track moves use Premiere's QE API and may not work on every version.",
+   "description": "Refuses attached transitions or unreadable transition collections before structural edits; inspect transitionsAffected and use remove_transition first. EXPERIMENTAL (undocumented QE DOM for track changes): Move a clip to a new position on the timeline; optional track moves use Premiere's QE API and may not work on every version.",
    "inputSchema": {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "additionalProperties": false,

+ tool added: open_extension

--- pinned/preview_extended_edit_plan
+++ observed/preview_extended_edit_plan
  {
    "annotations": {
      "destructiveHint": false,
-   "description": "Preview up to100 distinct bound CEP targets for supported trim, experimental QE split, same-track move, enable, scalar effect and keyframe steps. All targets and descriptor identities validate before token issuance; unsupported links/retiming/unknown source handles refuse. Requires exact saved project path and active sequence. No mutation or atomicity claim.",
+   "description": "Refuses attached transitions or unreadable transition collections before structural edits; inspect transitionsAffected and use remove_transition first. Preview up to100 distinct bound CEP targets for supported trim, experimental QE split, same-track move, enable, scalar effect and keyframe steps. All targets and descriptor identities validate before token issuance; unsupported links/retiming/unknown source handles refuse. Requires exact saved project path and active sequence. No mutation or atomicity claim.",
    "inputSchema": {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "additionalProperties": false,

+ tool added: remove_transition

--- pinned/ripple_delete
+++ observed/ripple_delete
  {
    "annotations": {
      "destructiveHint": true,
-   "description": "Remove a clip and close the gap it leaves, shifting later clips earlier on the clip's own track and on every sync-locked track so audio stays in sync. With the default scope the clip's linked audio/video partners are removed with it and their tracks close up too, even when not sync-locked; with scope 'own_track' the partners stay in place (reported as linkedPartnersKept). Premiere's QE rippleDelete() and the DOM's rippleEdit flag are both non-functional on 26.x, so this is done explicitly and verified. Refuses without changing anything if a clip on a participating track straddles the ripple point or sits inside the range being closed.",
+   "description": "Refuses attached transitions or unreadable transition collections before structural edits; inspect transitionsAffected and use remove_transition first. Remove a clip and close the gap it leaves, shifting later clips earlier on the clip's own track and on every sync-locked track so audio stays in sync. With the default scope the clip's linked audio/video partners are removed with it and their tracks close up too, even when not sync-locked; with scope 'own_track' the partners stay in place (reported as linkedPartnersKept). Premiere's QE rippleDelete() and the DOM's rippleEdit flag are both non-functional on 26.x, so this is done explicitly and verified. Refuses without changing anything if a clip on a participating track straddles the ripple point or sits inside the range being closed.",
    "inputSchema": {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "additionalProperties": false,

--- pinned/ripple_remove_timeline_ranges
+++ observed/ripple_remove_timeline_ranges
  {
    "annotations": {
      "destructiveHint": false,
-   "description": "Preview or apply a single-pass ripple removal for up to 50 sorted, non-overlapping timeline ranges on all unlocked, sync-locked tracks. Requires a preview confirmation token to apply. Integer frame rates only. The preview returns per-track counts and at most 50 planned-clip samples; clips fully inside ranges are removed. Large edits need allow_large_ripple: true.",
+   "description": "Refuses attached transitions or unreadable transition collections before structural edits; inspect transitionsAffected and use remove_transition first. Preview or apply a single-pass ripple removal for up to 50 sorted, non-overlapping timeline ranges on all unlocked, sync-locked tracks. Requires a preview confirmation token to apply. Integer frame rates only. The preview returns per-track counts and at most 50 planned-clip samples; clips fully inside ranges are removed. Kept pieces cut from one linked audio/video clip are relinked and read back after the move. Large edits need allow_large_ripple: true.",
    "inputSchema": {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "additionalProperties": false,

--- pinned/set_clip_anchor_point
+++ observed/set_clip_anchor_point
  {
    "annotations": {
      "destructiveHint": false,
-   "description": "Set the Anchor Point property on a video clip's Motion effect.",
+   "description": "Set and read back Motion Anchor Point in source-frame pixels by default, or explicit normalized 0–1 source-frame fractions. Omitted units with a 0–1 pair keeps pixels and adds a warning.",
    "inputSchema": {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "additionalProperties": false,
+       "units": {
+         "description": "Coordinate units; defaults to pixels for compatibility. normalized means 0–1 fractions of the sequence frame for Position or source frame for Anchor Point.",
+         "enum": [
+           "pixels",
+           "normalized"
+         ],
+         "type": "string"
+       },
        "x": {
-         "description": "Anchor point X in pixels",
+         "description": "Anchor point X in selected units: source-frame pixels by default or normalized 0–1 fractions.",
          "type": "number"
        },
        "y": {
-         "description": "Anchor point Y in pixels",
+         "description": "Anchor point Y in selected units: source-frame pixels by default or normalized 0–1 fractions.",
          "type": "number"
        }
      },

--- pinned/set_clip_duration
+++ observed/set_clip_duration
  {
    "annotations": {
      "destructiveHint": false,
-   "description": "Set one timeline clip's visible duration by moving only its timeline end (TrackItem.end) while keeping its start fixed. Pass exactly one of duration_seconds or end_seconds. Works for extending still images past their import length. Refuses to overlap the next clip on the same track, rejects shortening that would strand effect keyframes unless keyframe_policy is preserve, reads start/end back, and restores the original end if Premiere clamps or ignores the write (for example when video media has no handle left). Linked audio/video partners get the same change by default (include_linked), applied as the same end offset so partners with a J/L cut keep their offset; every clip is checked before any is changed. Use this instead of speed changes, which Premiere does not expose to scripting. Existing host Out padding below one sequence frame may be preserved or reduced, but never used to create additional padding. Non-still sources require readable ffprobe duration evidence and a readable sequence frame grid.",
+   "description": "Refuses attached transitions or unreadable transition collections before structural edits; inspect transitionsAffected and use remove_transition first. Set one timeline clip's visible duration by moving only its timeline end (TrackItem.end) while keeping its start fixed. Pass exactly one of duration_seconds or end_seconds. Works for extending still images past their import length. Refuses to overlap the next clip on the same track, rejects shortening that would strand effect keyframes unless keyframe_policy is preserve, reads start/end back, and restores the original end if Premiere clamps or ignores the write (for example when video media has no handle left). Linked audio/video partners get the same change by default (include_linked), applied as the same end offset so partners with a J/L cut keep their offset; every clip is checked before any is changed. Use this instead of speed changes, which Premiere does not expose to scripting. Existing host Out padding below one sequence frame may be preserved or reduced, but never used to create additional padding. Non-still sources require readable ffprobe duration evidence and a readable sequence frame grid.",
    "inputSchema": {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "additionalProperties": false,

--- pinned/set_clip_position
+++ observed/set_clip_position
  {
    "annotations": {
      "destructiveHint": false,
-   "description": "Set the Position property on a video clip's Motion effect using English or measured Spanish built-in names, then read it back. Values are in pixels.",
+   "description": "Set the Position property on a video clip's Motion effect using English or measured Spanish built-in names, then read it back. Values default to pixels; explicit normalized values are fractions from 0 to 1. Omitted units with a 0–1 pair keeps pixels and adds a warning.",
    "inputSchema": {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "additionalProperties": false,
+       "units": {
+         "description": "Coordinate units; defaults to pixels for compatibility. normalized means 0–1 fractions of the sequence frame for Position or source frame for Anchor Point.",
+         "enum": [
+           "pixels",
+           "normalized"
+         ],
+         "type": "string"
+       },
        "x": {
-         "description": "X position in sequence pixels (converted to Premiere's normalized Position when the host stores it that way)",
+         "description": "X position in the selected units: sequence pixels by default, or normalized 0–1 fractions.",
          "type": "number"
        },
        "y": {
-         "description": "Y position in sequence pixels (converted to Premiere's normalized Position when the host stores it that way)",
+         "description": "Y position in the selected units: sequence pixels by default, or normalized 0–1 fractions.",
          "type": "number"
        }
      },

--- pinned/set_clip_properties
+++ observed/set_clip_properties
  {
    "annotations": {
      "destructiveHint": false,
-   "description": "Set supported clip properties (opacity, scale, position, rotation) and read each requested value back. Clip speed is unsupported and fails before mutation; use set_clip_duration to change a clip's timeline length.",
+   "description": "Set supported clip properties (opacity, scale, position, rotation) and read each requested value back. Position uses pixels by default or explicit normalized 0–1 fractions; an omitted-unit 0–1 pair retains pixels with a warning. Clip speed is unsupported and fails before mutation; use set_clip_duration to change a clip's timeline length.",
    "inputSchema": {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "additionalProperties": false,
-         "description": "Horizontal position in sequence pixels",
+         "description": "Horizontal position in the selected units: sequence pixels by default or normalized 0–1 fractions.",
          "type": "number"
        },
        "position_y": {
-         "description": "Vertical position in sequence pixels",
+         "description": "Vertical position in the selected units: sequence pixels by default or normalized 0–1 fractions.",
          "type": "number"
        },
        "rotation": {
+       },
+       "units": {
+         "description": "Position units; pixels by default or normalized 0–1 sequence-frame fractions. Requires a position value.",
+         "enum": [
+           "pixels",
+           "normalized"
+         ],
+         "type": "string"
        }
      },
      "required": [

--- pinned/set_clip_properties_batch
+++ observed/set_clip_properties_batch
  {
    "annotations": {
      "destructiveHint": false,
-   "description": "Apply Motion/Opacity values to up to 16 clips after preflighting every target property. The handler reads each requested value back and never reports a partial batch as verified.",
+   "description": "Apply Motion/Opacity values to up to 16 clips after preflighting every target property. Position defaults to pixels or accepts explicit normalized 0–1 fractions; omitted-unit 0–1 pairs retain pixels and add per-item warnings. The handler reads each requested value back and never reports a partial batch as verified.",
    "inputSchema": {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "additionalProperties": false,
-               "description": "Motion horizontal position in sequence pixels.",
+               "description": "Motion horizontal position in selected units: sequence pixels by default or normalized 0–1 fractions.",
                "type": "number"
              },
              "position_y": {
-               "description": "Motion vertical position in sequence pixels.",
+               "description": "Motion vertical position in selected units: sequence pixels by default or normalized 0–1 fractions.",
                "type": "number"
              },
              "rotation": {
+             },
+             "units": {
+               "description": "Position units, pixels by default or normalized 0–1 sequence-frame fractions; requires a position value.",
+               "enum": [
+                 "pixels",
+                 "normalized"
+               ],
+               "type": "string"
              }
            },
            "required": [

--- pinned/trim_clip
+++ observed/trim_clip
  {
    "annotations": {
      "destructiveHint": false,
-   "description": "Trim exactly one source in/out point and verify the corresponding visible timeline edge. Requires accessible physical media duration from ffprobe; unknown duration or linked partners using different source files refuse before mutation. Refuses retimed clips, extensions that would overlap the neighbouring clip on the same track, and, by default, trims that would leave effect keyframes outside the visible clip. Linked audio/video partners get the same trim by default (include_linked), applied as the same offset from each partner's own source point so a J/L cut or slipped audio stays in sync; every clip is checked before any is changed. To set a clip's timeline length or extend a still image, use set_clip_duration. Existing host Out padding below one sequence frame may be preserved or reduced, but never used to create additional padding.",
+   "description": "Refuses attached transitions or unreadable transition collections before structural edits; inspect transitionsAffected and use remove_transition first. Trim exactly one source in/out point and verify the corresponding visible timeline edge. Requires accessible physical media duration from ffprobe; unknown duration or linked partners using different source files refuse before mutation. Refuses retimed clips, extensions that would overlap the neighbouring clip on the same track, and, by default, trims that would leave effect keyframes outside the visible clip. Linked audio/video partners get the same trim by default (include_linked), applied as the same offset from each partner's own source point so a J/L cut or slipped audio stays in sync; every clip is checked before any is changed. To set a clip's timeline length or extend a still image, use set_clip_duration. Existing host Out padding below one sequence frame may be preserved or reduced, but never used to create additional padding.",
    "inputSchema": {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "additionalProperties": false,

Changed 2026-10-25 11:11 UTC

4 descriptions rewritten, 430 schema or annotation changes with the description left byte-identical, 5 tools added.

--- pinned/acknowledge_operation_recovery
+++ observed/acknowledge_operation_recovery
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "reviewed": {
          "const": true,
          "description": "True only after reviewing current host state and reconciling the uncertain operations.",
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/add_adjustment_layer
+++ observed/add_adjustment_layer
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "track_index": {
          "description": "Video track index (default: 0)",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/add_audio_keyframes
+++ observed/add_audio_keyframes
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "keyframes": {
          "description": "Array of keyframe objects with time_seconds and level_db",
          "items": {
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/add_custom_metadata_field
+++ observed/add_custom_metadata_field
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "required": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/add_keyframe
+++ observed/add_keyframe
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/add_marker
+++ observed/add_marker
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "name": {
          "description": "Name/label for the marker",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/add_marker_to_project_item
+++ observed/add_marker_to_project_item
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the project item",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/add_markers_batch
+++ observed/add_markers_batch
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "markers": {
          "description": "Markers to create, in any order; they are sorted by time before writing.",
          "items": {
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/add_text_overlay
+++ observed/add_text_overlay
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "start_seconds": {
          "description": "Start time in seconds (default: 0)",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/add_title
+++ observed/add_title
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "lines": {
          "description": "Text for each of the template's text fields in order (see list_stock_titles). Specify exactly one of text or lines.",
          "items": {
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/add_to_render_queue
+++ observed/add_to_render_queue
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "output_path": {
          "description": "Full output file path",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/add_to_timeline
+++ observed/add_to_timeline
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the project item to add",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/add_to_timeline_batch
+++ observed/add_to_timeline_batch
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "required": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/add_track
+++ observed/add_track
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "track_type": {
          "description": "Type of track to add",
          "enum": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/add_tracks
+++ observed/add_tracks
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "video_tracks": {
          "description": "Number of video tracks to add (default: 0)",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/add_transition
+++ observed/add_transition
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "track_index": {
          "description": "Video track index (0-based)",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/add_transition_to_clip
+++ observed/add_transition_to_clip
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/adjust_audio_levels
+++ observed/adjust_audio_levels
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "level_db": {
          "description": "Audio level in dB (0 = unity, negative = quieter, positive = louder)",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/analyze_dialogue_edit_candidates
+++ observed/analyze_dialogue_edit_candidates
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/analyze_loudness
+++ observed/analyze_loudness
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "max_true_peak_dbfs": {
          "description": "Optional maximum acceptable true peak in dBFS (commonly -1 or -2)",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/analyze_video_interlacing
+++ observed/analyze_video_interlacing
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "media_path": {
          "description": "Existing local video file",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/analyze_video_qc
+++ observed/analyze_video_qc
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "media_path": {
          "description": "Path to an existing local video file",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/apply_after_effects_render_handoff
+++ observed/apply_after_effects_render_handoff
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "preview_token": {
          "description": "One-time ten-minute token from preview_after_effects_render_handoff.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/apply_audio_effect
+++ observed/apply_audio_effect
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/apply_edit_plan
+++ observed/apply_edit_plan
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "plan": {
          "additionalProperties": false,
          "description": "An edit plan: { sequence_id?, operations: [...] } with up to 100 insert_clip and remove_clip operations. Operations run in order, and each one's times refer to the timeline as the operations before it left it.",
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/apply_effect
+++ observed/apply_effect
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip to apply the effect to",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/apply_extended_edit_plan
+++ observed/apply_extended_edit_plan
  {
    "annotations": {
      "destructiveHint": true,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "required": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/apply_lut
+++ observed/apply_lut
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "lut_path": {
          "description": "Full path to the .cube or .3dl LUT file",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/apply_mogrt_premiere_handoff
+++ observed/apply_mogrt_premiere_handoff
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "preview_token": {
          "description": "One-time token returned by preview_mogrt_premiere_handoff.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/apply_scene_review_workflow
+++ observed/apply_scene_review_workflow
  {
    "annotations": {
      "destructiveHint": true,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "required": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/apply_spot_workflow_plan
+++ observed/apply_spot_workflow_plan
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "plan": {
          "description": "Exact plan returned by a preview_*_spot tool",
          "type": "object"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/apply_stacked_camera_edit
+++ observed/apply_stacked_camera_edit
  {
    "annotations": {
      "destructiveHint": true,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "required": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/attach_custom_property
+++ observed/attach_custom_property
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "property_id": {
          "description": "Unique identifier for the custom property",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

+ tool added: audit_project_structure

--- pinned/audit_timeline_health
+++ observed/audit_timeline_health
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/auto_reframe_sequence
+++ observed/auto_reframe_sequence
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "motion_preset": {
          "description": "Premiere Auto Reframe motion preset (default: default)",
          "enum": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/batch_add_transitions
+++ observed/batch_add_transitions
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "track_index": {
          "description": "Video track index (0-based, default: 0)",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/batch_apply_effect
+++ observed/batch_apply_effect
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "target": {
          "description": "Which clips to apply to: selected clips, all on a track, or all in sequence",
          "enum": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/batch_enable_disable
+++ observed/batch_enable_disable
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "target": {
          "description": "Which clips to affect",
          "enum": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/batch_rename_clips
+++ observed/batch_rename_clips
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "pattern": {
          "description": "Name pattern. Use {n} for a sequential number, ## for a zero-padded two-digit sequence number, and {name} for the original name (e.g., 'Scene_##', '{name}_v2')",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/bind_media_provenance
+++ observed/bind_media_provenance
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/build_caption_artifact
+++ observed/build_caption_artifact
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "karaoke": {
          "description": "VTT only: emit per-word <HH:MM:SS.mmm> timestamps inside each cue for word-highlight styles. Errors for SRT.",
          "type": "boolean"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/build_edit_review_evidence
+++ observed/build_edit_review_evidence
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "operation_revision": {
          "description": "Reviewed operation/snapshot revision that this evidence accompanies; declared, not host-authenticated.",
          "maxLength": 128,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/build_project_handoff_manifest
+++ observed/build_project_handoff_manifest
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "inventory_complete": {
          "description": "Whether upstream dependency enumeration is complete, including nested/external sources.",
          "type": "boolean"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/can_execute
+++ observed/can_execute
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/cancel_workflow_job
+++ observed/cancel_workflow_job
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "job_id": {
          "description": "Exact tracked job ID; missing receipts never imply completion.",
          "maxLength": 128,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/capture_frame
+++ observed/capture_frame
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "time_seconds": {
          "description": "Time position in seconds to capture. Uses current playhead if omitted.",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/check_caption_safe_zone
+++ observed/check_caption_safe_zone
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/check_offline_media
+++ observed/check_offline_media
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/clear_item_in_out
+++ observed/clear_item_in_out
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the project item",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/clear_sequence_in_out
+++ observed/clear_sequence_in_out
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "type": "object"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/close_all_source_clips
+++ observed/close_all_source_clips
  {
    "annotations": {
      "destructiveHint": true,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "type": "object"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/close_project
+++ observed/close_project
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "project_path": {
          "description": "Path of the open project to close (default: the active project)",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/close_sequence
+++ observed/close_sequence
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "sequence_id": {
          "description": "Sequence name or ID. Uses active sequence if omitted.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/close_source_monitor
+++ observed/close_source_monitor
  {
    "annotations": {
      "destructiveHint": true,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "type": "object"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/color_correct
+++ observed/color_correct
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/compare_cmx3600_edls
+++ observed/compare_cmx3600_edls
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "required": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/compute_mask_fit_motion
+++ observed/compute_mask_fit_motion
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/consolidate_and_transfer
+++ observed/consolidate_and_transfer
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "include_all_sequences": {
          "description": "Include all sequences (default: true). If false, only active sequence is used.",
          "type": "boolean"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/consolidate_duplicates
+++ observed/consolidate_duplicates
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "type": "object"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/convert_timeline_time
+++ observed/convert_timeline_time
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/copy_effect_values
+++ observed/copy_effect_values
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "source_node_id": {
          "description": "Node ID of the source clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/copy_effects_between_clips
+++ observed/copy_effects_between_clips
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "source_node_id": {
          "description": "Node ID of the source clip to copy effects from",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/create_bars_and_tone
+++ observed/create_bars_and_tone
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "name": {
          "description": "Name for the bars and tone item (default: 'Bars and Tone')",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/create_bin
+++ observed/create_bin
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "name": {
          "description": "Name of the new bin",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/create_caption_track
+++ observed/create_caption_track
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "For action import, the node ID or name of the imported caption project item (for example, an SRT file). Omit for plan_lecture_workflow.",
          "maxLength": 512,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/create_context_edit_plan
+++ observed/create_context_edit_plan
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/create_editorial_context_pack
+++ observed/create_editorial_context_pack
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/create_editorial_plan
+++ observed/create_editorial_plan
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/create_mogrt_batch
+++ observed/create_mogrt_batch
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "preview_token": {
          "description": "One-time token returned by preview_mogrt_batch.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/create_mogrt_recipe
+++ observed/create_mogrt_recipe
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "preview_token": {
          "description": "One-time token returned by preview_mogrt_recipe; it expires after 10 minutes.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/create_project
+++ observed/create_project
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "path": {
          "description": "Full file path for the new .prproj file",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/create_project_backup
+++ observed/create_project_backup
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "project_path": {
          "description": "Absolute or working-directory-relative path to an existing .prproj file",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/create_sequence
+++ observed/create_sequence
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "name": {
          "description": "Name for the new sequence",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/create_sequence_checkpoint
+++ observed/create_sequence_checkpoint
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "include_snapshot": {
          "description": "Return the original sequence's structural snapshot for later diff_sequence_snapshots calls (default true).",
          "type": "boolean"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/create_sequence_from_clips
+++ observed/create_sequence_from_clips
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_ids": {
          "description": "Array of project item names or node IDs to include in order",
          "items": {
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/create_sequence_from_preset
+++ observed/create_sequence_from_preset
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "name": {
          "description": "Name for the new sequence",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/create_smart_bin
+++ observed/create_smart_bin
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "name": {
          "description": "Name for the smart bin",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

+ tool added: create_source_freeze_frame

--- pinned/create_subclip
+++ observed/create_subclip
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "in_seconds": {
          "description": "In-point in seconds",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/create_subsequence
+++ observed/create_subsequence
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "ignore_track_targeting": {
          "description": "Whether to ignore track targeting (default: false)",
          "type": "boolean"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/crop_clip
+++ observed/crop_clip
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "left": {
          "description": "Percent cropped from the left edge.",
          "maximum": 100,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/delete_bin
+++ observed/delete_bin
  {
    "annotations": {
      "destructiveHint": true,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "required": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/delete_marker
+++ observed/delete_marker
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Optional clip node ID (deletes from sequence if omitted). Premiere 25.2.3 timeline clips have no marker collection, so this refuses there.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/delete_multiple_project_items
+++ observed/delete_multiple_project_items
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_ids": {
          "description": "Array of node IDs or names of items to delete",
          "items": {
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/delete_preview_files
+++ observed/delete_preview_files
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "media_type": {
          "description": "Type of preview files to delete: 'video', 'audio', or 'all' (default: 'all')",
          "enum": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/delete_project_item
+++ observed/delete_project_item
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the project item to delete",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/delete_sequence
+++ observed/delete_sequence
  {
    "annotations": {
      "destructiveHint": true,
-   "description": "Delete a sequence from the project",
+   "description": "Delete a sequence from the project and read back that it is gone. A sequence nested on another timeline is refused unless confirm_remove_from_sequences is true, matching delete_project_item; deleting it would remove or orphan those nested clips.",
    "inputSchema": {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "additionalProperties": false,
+       "confirm_remove_from_sequences": {
+         "description": "Delete even when this sequence is nested on another timeline, which also removes those nested clips (default: false).",
+         "type": "boolean"
+       },
        "expected_cep_target": {
          "additionalProperties": false,
          "anyOf": [
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "sequence_id": {
          "description": "Sequence name or ID to delete",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/delete_track
+++ observed/delete_track
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "track_index": {
          "description": "Index of the track to delete (0-based)",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/deselect_all_clips
+++ observed/deselect_all_clips
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "type": "object"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/detach_proxy
+++ observed/detach_proxy
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the project item",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/detect_active_picture_bounds
+++ observed/detect_active_picture_bounds
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "limit": {
          "description": "Cropdetect black threshold from 0 through 255 (default: 24)",
          "type": "integer"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/detect_audio_transients
+++ observed/detect_audio_transients
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "maximum_events": {
          "description": "Maximum returned candidates from 1 through 1000 (default: 200)",
          "type": "integer"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/detect_beats
+++ observed/detect_beats
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "max_beats": {
          "description": "Maximum beat times returned (default: 500).",
          "maximum": 2000,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/detect_motion_peaks
+++ observed/detect_motion_peaks
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "maximum_events": {
          "description": "Maximum returned candidates from 1 through 1000 (default: 200)",
          "type": "integer"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/detect_repeated_takes
+++ observed/detect_repeated_takes
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/detect_scene_edits
+++ observed/detect_scene_edits
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "mode": {
          "description": "How Premiere should materialize detected edits on the current native selection.",
          "enum": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/detect_silence
+++ observed/detect_silence
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "media_path": {
          "description": "Absolute path to the media file to analyse. Provide this or project_item_id.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/detect_source_scene_changes
+++ observed/detect_source_scene_changes
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "maximum_events": {
          "description": "Maximum returned changes (default: 500; maximum: 2000)",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/diff_sequence_snapshots
+++ observed/diff_sequence_snapshots
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/duplicate_clip
+++ observed/duplicate_clip
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip to duplicate",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/duplicate_sequence
+++ observed/duplicate_sequence
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "sequence_id": {
          "description": "Sequence name or ID to duplicate",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/enable_disable_clip
+++ observed/enable_disable_clip
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/encode_file
+++ observed/encode_file
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "in_seconds": {
          "description": "Optional start time in seconds",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/encode_project_item
+++ observed/encode_project_item
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the project item to encode",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/enqueue_after_effects_render
+++ observed/enqueue_after_effects_render
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "preview_token": {
          "description": "One-time token returned by preview_after_effects_render.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/export_aaf
+++ observed/export_aaf
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "mix_down_video": {
          "description": "Mix down video to single track (default: true)",
          "type": "boolean"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/export_and_verify
+++ observed/export_and_verify
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "output_path": {
          "description": "New absolute delivery destination, with extension matching the preset.",
          "maxLength": 4096,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/export_as_fcp_xml
+++ observed/export_as_fcp_xml
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "output_path": {
          "description": "Full output file path (e.g., '/Users/me/export.xml')",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/export_as_project
+++ observed/export_as_project
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "output_path": {
          "description": "Full path for the exported .prproj file",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/export_facility_metadata_table
+++ observed/export_facility_metadata_table
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "output_path": {
          "description": "Absolute caller-selected local file path. Referenced media is never opened automatically.",
          "maxLength": 4096,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/export_frame
+++ observed/export_frame
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "output_path": {
          "description": "Full output file path (e.g., '/Users/me/frame.png'). Extension determines format.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/export_omf
+++ observed/export_omf
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "include_pan": {
          "description": "Include pan information in the OMF (default: false)",
          "type": "boolean"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/export_review_markers
+++ observed/export_review_markers
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "markers": {
          "description": "Reviewed marker readback; empty sequences still emit CSV headers.",
          "items": {
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/export_sequence
+++ observed/export_sequence
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "output_path": {
          "description": "Full output file path (e.g., '/Users/me/exports/video.mp4')",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/export_sequence_clip_review_frames
+++ observed/export_sequence_clip_review_frames
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "limit": {
          "description": "Maximum clips to sample (default: 20; maximum: 50)",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/export_sequence_edl
+++ observed/export_sequence_edl
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "include_clip_name_comments": {
          "description": "Emit '* FROM CLIP NAME:' comments (default true).",
          "type": "boolean"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

+ tool added: export_sequence_job_start

--- pinned/export_sequence_marker_review_frames
+++ observed/export_sequence_marker_review_frames
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "limit": {
          "description": "Maximum chronological marker frames to export (default: 12; minimum: 1; maximum: 24).",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/export_sequence_review_frames
+++ observed/export_sequence_review_frames
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "output_dir": {
          "description": "Existing directory where review_001.png through review_NNN.png will be written",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/extract_selection
+++ observed/extract_selection
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "type": "object"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/find_item_usages
+++ observed/find_item_usages
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/find_items_by_media_path
+++ observed/find_items_by_media_path
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/find_project_item_by_name
+++ observed/find_project_item_by_name
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/freeze_frame
+++ observed/freeze_frame
  {
    "annotations": {
      "destructiveHint": false,
-   "description": "Create a freeze frame from a clip at a specific time. Exports the frame, imports it back as a still image, and sets the still's Out mark to duration_seconds so add_to_timeline places it at that length (snapped to the still's frame grid, then to the sequence frame). It does not place the still on the timeline.",
+   "description": "Create a freeze frame from a clip at a specific SEQUENCE time (for a source-media time, use create_source_freeze_frame). Exports the frame, imports it back as a still image, and sets the still's Out mark to duration_seconds so add_to_timeline places it at that length (snapped to the still's frame grid, then to the sequence frame). It does not place the still on the timeline.",
    "inputSchema": {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "additionalProperties": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "output_path": {
          "description": "Full path for the exported frame (e.g., /path/to/freeze.png)",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/generate_media_contact_sheet
+++ observed/generate_media_contact_sheet
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "media_path": {
          "description": "Existing local video file",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_active_sequence
+++ observed/get_active_sequence
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_advanced_feature_support
+++ observed/get_advanced_feature_support
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_all_project_paths
+++ observed/get_all_project_paths
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_av_feature_support
+++ observed/get_av_feature_support
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_bin_contents
+++ observed/get_bin_contents
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_bridge_telemetry
+++ observed/get_bridge_telemetry
  {
    "annotations": {
      "destructiveHint": false,
-   "description": "Inspect privacy-preserving aggregate bridge health: pending command/response counts, busy operations, queue age, and CEP heartbeat state without returning project or personal data.",
+   "description": "Read-only, sends no command: inspect privacy-preserving aggregate bridge health (pending command/response counts, busy operations, queue age, CEP heartbeat state) and diagnose whether the CEP bridge is blocked. Use it after a timeout or before retrying: a modal dialog such as Missing Media blocks Premiere's scripting engine, so a probe script cannot run. blocking.state is idle, busy, likely_blocked_by_dialog, stuck, connector_not_running, or unknown, with reason, ages in ms, queued counts, the running tool name when known, and nextSteps. It reads only heartbeat and busy-marker timing; no OS window probe is performed (macOS needs Accessibility permission and window titles can name media), and no dialog is dismissed. Returns no paths, file names, or script contents.",
    "inputSchema": {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "additionalProperties": false,
+       "expected_command_ms": {
+         "description": "How long the in-flight command is expected to take, in ms (default: the bridge timeout, 30000). A command still running past this while the panel is alive is reported as likely_blocked_by_dialog. Raise it for long exports.",
+         "maximum": 3600000,
+         "minimum": 1000,
+         "type": "integer"
+       },
        "expected_project_path": {
          "description": "Optional absolute saved-project path. Every generated CEP command refuses before its body when the active project differs or is unsaved. UXP commands refuse this CEP-only guard; local-only tools do not inspect Premiere. Omit to keep existing behavior.",
          "maxLength": 4096,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_capabilities
+++ observed/get_capabilities
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_caption_style_guidance
+++ observed/get_caption_style_guidance
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_clip_adjustment_layer
+++ observed/get_clip_adjustment_layer
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_clip_at_playhead
+++ observed/get_clip_at_playhead
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_clip_at_position
+++ observed/get_clip_at_position
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_clip_links
+++ observed/get_clip_links
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_clip_markers
+++ observed/get_clip_markers
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_clip_properties
+++ observed/get_clip_properties
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_clip_speed
+++ observed/get_clip_speed
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_clip_volume
+++ observed/get_clip_volume
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_color_label
+++ observed/get_color_label
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_color_space
+++ observed/get_color_space
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_duplicate_media
+++ observed/get_duplicate_media
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_effect_properties
+++ observed/get_effect_properties
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_encoder_presets
+++ observed/get_encoder_presets
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_export_file_extension
+++ observed/get_export_file_extension
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "preset_path": {
          "description": "Full path to the export preset file (.epr)",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

+ tool added: get_export_job_status

--- pinned/get_footage_interpretation
+++ observed/get_footage_interpretation
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_full_clip_info
+++ observed/get_full_clip_info
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_full_project_overview
+++ observed/get_full_project_overview
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_full_sequence_info
+++ observed/get_full_sequence_info
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_graphics_white_luminance
+++ observed/get_graphics_white_luminance
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_insertion_bin
+++ observed/get_insertion_bin
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_item_info
+++ observed/get_item_info
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_keyframes
+++ observed/get_keyframes
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_last_operations
+++ observed/get_last_operations
  {
    "annotations": {
      "destructiveHint": false,
-   "description": "Read-only: list the most recent state-changing tool calls this MCP server process handled, newest first, with status (running, succeeded, failed), receipt outcome and timing. Use it after a client-side timeout before retrying an edit: a call still running, or one that already succeeded, must not be sent again. The running count includes all active calls, even outside the history window; runningOperations lists up to limit active calls and runningOperationsTruncated flags omitted entries. Records only tool names, timing and outcomes; it does not prove Premiere state, and it starts empty when the server restarts.",
+   "description": "Read-only: list the most recent state-changing tool calls this MCP server process handled, newest first, with status (running, succeeded, failed), receipt outcome and timing. Use it after a client-side timeout before retrying an edit: a call still running, or one that already succeeded, must not be sent again. The running count includes all active calls, even outside the history window; runningOperations lists up to limit active calls and runningOperationsTruncated flags omitted entries. Entries made with idempotency_key carry idempotencyKeyHash, a 12-character SHA-256 prefix (never the raw key). Records only tool names, timing and outcomes; it does not prove Premiere state, and it starts empty when the server restarts.",
    "inputSchema": {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "additionalProperties": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_linked_items
+++ observed/get_linked_items
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_metadata
+++ observed/get_metadata
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_mogrt_component
+++ observed/get_mogrt_component
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_next_edit_point
+++ observed/get_next_edit_point
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_offline_media
+++ observed/get_offline_media
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_operation_performance
+++ observed/get_operation_performance
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_playhead_position
+++ observed/get_playhead_position
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_premiere_state
+++ observed/get_premiere_state
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_project_info
+++ observed/get_project_info
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_project_item_info
+++ observed/get_project_item_info
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_project_panel_metadata
+++ observed/get_project_panel_metadata
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_project_scratch_disks
+++ observed/get_project_scratch_disks
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_qe_clip_info
+++ observed/get_qe_clip_info
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_render_queue_status
+++ observed/get_render_queue_status
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_selected_clips
+++ observed/get_selected_clips
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_sequence_count
+++ observed/get_sequence_count
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_sequence_in_out_points
+++ observed/get_sequence_in_out_points
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_sequence_markers_by_type
+++ observed/get_sequence_markers_by_type
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_sequence_settings
+++ observed/get_sequence_settings
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_sequence_structure
+++ observed/get_sequence_structure
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_source_monitor_info
+++ observed/get_source_monitor_info
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_source_monitor_position
+++ observed/get_source_monitor_position
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_target_tracks
+++ observed/get_target_tracks
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_timeline_gaps
+++ observed/get_timeline_gaps
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_timeline_summary
+++ observed/get_timeline_summary
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_total_clip_count
+++ observed/get_total_clip_count
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_track_info
+++ observed/get_track_info
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_unused_media
+++ observed/get_unused_media
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_used_media_report
+++ observed/get_used_media_report
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_value_at_time
+++ observed/get_value_at_time
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_version_info
+++ observed/get_version_info
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_work_area
+++ observed/get_work_area
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_workspaces
+++ observed/get_workspaces
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/get_xmp_metadata
+++ observed/get_xmp_metadata
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/has_proxy
+++ observed/has_proxy
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/import_ae_comps
+++ observed/import_ae_comps
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "target_bin": {
          "description": "Target bin name or node ID (optional)",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/import_edl
+++ observed/import_edl
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "required": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/import_fcp_xml
+++ observed/import_fcp_xml
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "mode": {
          "description": "new_project (default) opens the XML as a new project saved at project_path. into_open_project imports it into the open project.",
          "enum": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/import_folder
+++ observed/import_folder
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "target_bin": {
          "description": "Optional bin name or node ID to import into. Defaults to the project root.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/import_image_sequence
+++ observed/import_image_sequence
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "target_bin": {
          "description": "Target bin name to import into (optional, imports to root if omitted)",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/import_media
+++ observed/import_media
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "suppress_ui": {
          "description": "Suppress import dialogs (default: true)",
          "type": "boolean"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/import_mogrt
+++ observed/import_mogrt
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "mogrt_path": {
          "description": "Full path to the .mogrt file",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/import_mogrt_from_library
+++ observed/import_mogrt_from_library
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "library_name": {
          "description": "Name of the Adobe Creative Cloud Library that contains the MOGRT",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/import_sequences
+++ observed/import_sequences
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "project_path": {
          "description": "Full path to the source .prproj file",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/insert_from_source
+++ observed/insert_from_source
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "scope": {
          "description": "Which tracks shift: 'sync_locked' (default) matches Premiere's insert and keeps sync-locked tracks in sync; 'target_tracks' ripples only the named pair and WILL desync other tracks.",
          "enum": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_after_effects_render_templates
+++ observed/inspect_after_effects_render_templates
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_after_effects_template_source
+++ observed/inspect_after_effects_template_source
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_cmx3600_edl
+++ observed/inspect_cmx3600_edl
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "path": {
          "description": "Existing local .edl file",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_dom_object
+++ observed/inspect_dom_object
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_edit_readiness
+++ observed/inspect_edit_readiness
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_fcpxml_interchange
+++ observed/inspect_fcpxml_interchange
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "path": {
          "description": "Existing local .fcpxml or .xml file",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_film_editorial_workflow
+++ observed/inspect_film_editorial_workflow
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_interchange_artifact
+++ observed/inspect_interchange_artifact
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "path": {
          "description": "Absolute caller-selected local file path. Referenced media is never opened automatically.",
          "maxLength": 4096,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_interchange_loss_report
+++ observed/inspect_interchange_loss_report
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "path": {
          "description": "Absolute caller-selected local file path. Referenced media is never opened automatically.",
          "maxLength": 4096,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_media_streams
+++ observed/inspect_media_streams
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "media_path": {
          "description": "Existing local media file",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_mogrt_library
+++ observed/inspect_mogrt_library
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "library_directory": {
          "description": "Existing workspace-contained local library root.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_operation_recovery
+++ observed/inspect_operation_recovery
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_otio_interchange
+++ observed/inspect_otio_interchange
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "path": {
          "description": "Absolute caller-selected local file path. Referenced media is never opened automatically.",
          "maxLength": 4096,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_project_item_av_metadata
+++ observed/inspect_project_item_av_metadata
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_project_recovery
+++ observed/inspect_project_recovery
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_rendered_video_scopes
+++ observed/inspect_rendered_video_scopes
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "output_path": {
          "description": "Existing rendered video to sample.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_sequence_av_settings
+++ observed/inspect_sequence_av_settings
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_sequence_review_report
+++ observed/inspect_sequence_review_report
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_stabilizer_status
+++ observed/inspect_stabilizer_status
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_timeline_snapshot
+++ observed/inspect_timeline_snapshot
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_workflow_checkpoint
+++ observed/inspect_workflow_checkpoint
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "required": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/inspect_workflow_job
+++ observed/inspect_workflow_job
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/invert_selection
+++ observed/invert_selection
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "type": "object"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/is_work_area_enabled
+++ observed/is_work_area_enabled
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/lift_selection
+++ observed/lift_selection
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "type": "object"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/link_selection
+++ observed/link_selection
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "type": "object"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/list_available_audio_effects
+++ observed/list_available_audio_effects
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/list_available_audio_transitions
+++ observed/list_available_audio_transitions
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/list_available_effects
+++ observed/list_available_effects
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/list_available_transitions
+++ observed/list_available_transitions
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/list_clip_effects
+++ observed/list_clip_effects
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/list_markers
+++ observed/list_markers
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/list_project_items
+++ observed/list_project_items
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/list_sequence_checkpoints
+++ observed/list_sequence_checkpoints
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/list_sequence_tracks
+++ observed/list_sequence_tracks
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/list_sequences
+++ observed/list_sequences
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/list_stock_titles
+++ observed/list_stock_titles
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/lock_track
+++ observed/lock_track
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "locked": {
          "description": "True to lock, false to unlock",
          "type": "boolean"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/manage_media_watch
+++ observed/manage_media_watch
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "recursive": {
          "description": "Monitor contained subdirectories; defaults to false.",
          "type": "boolean"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/manage_project_context
+++ observed/manage_project_context
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "project_id": {
          "description": "Project context ID returned by capture; optional for status to list projects",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/manage_proxies
+++ observed/manage_proxies
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the project item",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/map_keyframe_time_domain
+++ observed/map_keyframe_time_domain
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/map_source_ranges_to_timeline
+++ observed/map_source_ranges_to_timeline
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/map_word_timeline_occurrences
+++ observed/map_word_timeline_occurrences
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/match_frame
+++ observed/match_frame
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/move_clip
+++ observed/move_clip
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "new_start_seconds": {
          "description": "New start time in seconds",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/move_clip_to_track
+++ observed/move_clip_to_track
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/move_item_to_bin
+++ observed/move_item_to_bin
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the item to move",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/move_items_to_bin
+++ observed/move_items_to_bin
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_ids": {
          "description": "Array of node IDs or names of items to move",
          "items": {
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/move_playhead_to_edit
+++ observed/move_playhead_to_edit
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "type": "object"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/multiple_undo
+++ observed/multiple_undo
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "required": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/mute_track
+++ observed/mute_track
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "muted": {
          "description": "True to mute, false to unmute",
          "type": "boolean"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/navigate_playhead
+++ observed/navigate_playhead
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "track_index": {
          "description": "Restrict edit points to one track index.",
          "maximum": 255,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/nest_clips
+++ observed/nest_clips
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "name": {
          "description": "Name for the nested sequence",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/normalize_loudness_file
+++ observed/normalize_loudness_file
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "input_path": {
          "description": "Existing local audio or video file",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/open_in_source
+++ observed/open_in_source
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the project item to open",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/open_project
+++ observed/open_project
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "path": {
          "description": "Full file path to the .prproj file",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/overwrite_clip
+++ observed/overwrite_clip
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the project item to add",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/overwrite_from_source
+++ observed/overwrite_from_source
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "video_track_index": {
          "description": "Target video track index (default: 0)",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/paste_clip_attributes
+++ observed/paste_clip_attributes
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "source_node_id": {
          "description": "Node ID of the source timeline clip in the active sequence whose attributes are copied",
          "maxLength": 512,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/ping
+++ observed/ping
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_active_speaker_reframe
+++ observed/plan_active_speaker_reframe
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_audio_post_turnover
+++ observed/plan_audio_post_turnover
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_beat_montage
+++ observed/plan_beat_montage
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_chapter_markers
+++ observed/plan_chapter_markers
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_client_notes_checklist
+++ observed/plan_client_notes_checklist
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_cross_app_workflow
+++ observed/plan_cross_app_workflow
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_emphasis_zoom_keyframes
+++ observed/plan_emphasis_zoom_keyframes
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_filler_word_removal
+++ observed/plan_filler_word_removal
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_media_synchronization
+++ observed/plan_media_synchronization
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_multicam_angle_switches
+++ observed/plan_multicam_angle_switches
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_music_remix
+++ observed/plan_music_remix
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_pause_tightening
+++ observed/plan_pause_tightening
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_platform_delivery_matrix
+++ observed/plan_platform_delivery_matrix
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_reaction_captions
+++ observed/plan_reaction_captions
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_scene_segments
+++ observed/plan_scene_segments
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_short_export_folder
+++ observed/plan_short_export_folder
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_short_subscribe_cta
+++ observed/plan_short_subscribe_cta
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_shot_match
+++ observed/plan_shot_match
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "reference_media_path": {
          "description": "Existing local reference video file",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_silence_review_markers
+++ observed/plan_silence_review_markers
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_speaker_checkerboard
+++ observed/plan_speaker_checkerboard
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/plan_word_mute_ranges
+++ observed/plan_word_mute_ranges
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/play_source_monitor
+++ observed/play_source_monitor
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "speed": {
          "description": "Playback speed (1.0 = normal, 2.0 = 2x, -1.0 = reverse). Default: 1.0",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/play_timeline
+++ observed/play_timeline
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "type": "object"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/predict_timeline_edit
+++ observed/predict_timeline_edit
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/prepare_transcript_workflow
+++ observed/prepare_transcript_workflow
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "language": {
          "description": "Optional approved host language.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/preview_after_effects_render
+++ observed/preview_after_effects_render
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "output_module_template": {
          "description": "Exact After Effects output-module template name.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/preview_after_effects_render_handoff
+++ observed/preview_after_effects_render_handoff
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "output_path": {
          "description": "Existing completed .mov, .mp4, .mxf, .avi or .wav render; image sequences are not supported.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/preview_brand_spot
+++ observed/preview_brand_spot
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/preview_edit_plan
+++ observed/preview_edit_plan
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/preview_editorial_plan
+++ observed/preview_editorial_plan
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/preview_extended_edit_plan
+++ observed/preview_extended_edit_plan
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/preview_facility_metadata_intake
+++ observed/preview_facility_metadata_intake
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "match_column": {
          "description": "ALE column matched exactly against caller-reviewed source filenames.",
          "maxLength": 64,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/preview_mogrt_batch
+++ observed/preview_mogrt_batch
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "output_directory": {
          "description": "Existing workspace-contained directory for every batch artifact.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/preview_mogrt_library_publish
+++ observed/preview_mogrt_library_publish
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "library_directory": {
          "description": "Existing workspace-contained local library root.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/preview_mogrt_premiere_handoff
+++ observed/preview_mogrt_premiere_handoff
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "mogrt_path": {
          "description": "Existing workspace-contained MOGRT artifact.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/preview_mogrt_recipe
+++ observed/preview_mogrt_recipe
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "output_directory": {
          "description": "Existing absolute output directory inside approved_workspace_path; this workflow never creates directories.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/preview_motion_graphics_demo
+++ observed/preview_motion_graphics_demo
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/preview_otio_snapshot_export
+++ observed/preview_otio_snapshot_export
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/preview_product_spot
+++ observed/preview_product_spot
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/preview_project_intake
+++ observed/preview_project_intake
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/preview_scene_review_workflow
+++ observed/preview_scene_review_workflow
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "mode": {
          "description": "Explicit supported source-marker and/or subclip workflow.",
          "enum": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/preview_stacked_camera_edit
+++ observed/preview_stacked_camera_edit
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/preview_watched_media_import
+++ observed/preview_watched_media_import
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "include_paths": {
          "description": "Explicitly disclose contained paths for selected imports; defaults to false.",
          "type": "boolean"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/preview_workflow_recipe
+++ observed/preview_workflow_recipe
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "provided_inputs": {
          "description": "Names of inputs already available to the caller; values are intentionally not persisted in the recipe preview.",
          "items": {
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/publish_mogrt_to_library
+++ observed/publish_mogrt_to_library
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "preview_token": {
          "description": "One-time token returned by preview_mogrt_library_publish.",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/rank_short_form_candidates
+++ observed/rank_short_form_candidates
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/razor_all_tracks
+++ observed/razor_all_tracks
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "time_seconds": {
          "description": "Time to razor at in seconds (uses playhead position if omitted)",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/read_sequence_captions
+++ observed/read_sequence_captions
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/read_video_scopes
+++ observed/read_video_scopes
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "media_path": {
          "description": "Existing local video file",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/redo
+++ observed/redo
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "required": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/refresh_media
+++ observed/refresh_media
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the item to refresh",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/relink_media
+++ observed/relink_media
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the item to relink",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/remove_all_effects
+++ observed/remove_all_effects
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/remove_effect
+++ observed/remove_effect
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/remove_effect_by_name
+++ observed/remove_effect_by_name
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/remove_from_timeline
+++ observed/remove_from_timeline
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "include_linked": {
          "description": "Also remove the clip's linked audio/video partners (default: true). A ripple removal always includes them, since closing the gap on one side only would desync the timeline.",
          "type": "boolean"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/remove_keyframe
+++ observed/remove_keyframe
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/remove_keyframe_range
+++ observed/remove_keyframe_range
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/remove_selected_clips
+++ observed/remove_selected_clips
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "ripple": {
          "description": "Ripple removal is unsupported and refused before editing. Default: false",
          "type": "boolean"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/rename_bin
+++ observed/rename_bin
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "new_name": {
          "description": "New name for the bin",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/rename_clip
+++ observed/rename_clip
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "new_name": {
          "description": "New name for the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/rename_project_item
+++ observed/rename_project_item
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the project item",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/rename_track
+++ observed/rename_track
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "name": {
          "description": "New track name",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/replace_clip
+++ observed/replace_clip
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "new_item_id": {
          "description": "Node ID or name of the new project item to replace with",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/replace_clip_media
+++ observed/replace_clip_media
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "new_item_id": {
          "description": "Node ID or name of the new source project item",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

+ tool added: retime_caption_file

--- pinned/reverse_clip
+++ observed/reverse_clip
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/review_broll_placements
+++ observed/review_broll_placements
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/review_dialogue_candidates
+++ observed/review_dialogue_candidates
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/review_quote_paper_edit
+++ observed/review_quote_paper_edit
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/review_sync_evidence
+++ observed/review_sync_evidence
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/review_text_changes
+++ observed/review_text_changes
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/ripple_delete
+++ observed/ripple_delete
  {
    "annotations": {
      "destructiveHint": true,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "large_ripple_threshold": {
          "description": "Mover count above which ripple_delete refuses unless allow_large_ripple is true (default: 400).",
          "maximum": 5000,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/ripple_remove_timeline_ranges
+++ observed/ripple_remove_timeline_ranges
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "range_content": {
          "description": "Delete clips fully inside each removed range.",
          "enum": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/roll_edit
+++ observed/roll_edit
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "include_linked": {
          "description": "Also apply the edit to the clip's linked audio/video partners so picture and sound stay in sync (default: true).",
          "type": "boolean"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/save_project
+++ observed/save_project
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "type": "object"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/save_project_as
+++ observed/save_project_as
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "path": {
          "description": "Full file path to save the project to (e.g., '/Users/me/projects/MyProject.prproj')",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/save_workflow_checkpoint
+++ observed/save_workflow_checkpoint
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "required": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/scene_edit_detection
+++ observed/scene_edit_detection
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "sensitivity": {
          "description": "Scene-detection sensitivity (default: MediumSensitivity)",
          "enum": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/search_project_context
+++ observed/search_project_context
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/search_project_items
+++ observed/search_project_items
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/search_workflow_recipes
+++ observed/search_workflow_recipes
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "query": {
          "description": "Optional case-insensitive title, description, tag, or ID query.",
          "maxLength": 256,
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/select_all_clips
+++ observed/select_all_clips
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "track_index": {
          "description": "Specific track index (optional, selects all tracks if omitted)",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/select_clips_by_color
+++ observed/select_clips_by_color
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "required": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/select_clips_by_name
+++ observed/select_clips_by_name
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "name": {
          "description": "Clip name to search for (case-insensitive substring match)",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/select_clips_by_pattern
+++ observed/select_clips_by_pattern
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "include_disabled": {
          "description": "Include disabled clips as candidates (default true).",
          "type": "boolean"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/select_clips_in_range
+++ observed/select_clips_in_range
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "start_seconds": {
          "description": "Start of selection range in seconds",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/select_disabled_clips
+++ observed/select_disabled_clips
  {
    "annotations": {
      "destructiveHint": false,
+       },
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
        }
      },
      "type": "object"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/select_item
+++ observed/select_item
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the project item to select",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_active_sequence
+++ observed/set_active_sequence
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "sequence_id": {
          "description": "Sequence name or ID to make active",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_all_tracks_targeted
+++ observed/set_all_tracks_targeted
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "targeted": {
          "description": "Whether to target (true) or untarget (false) all tracks",
          "type": "boolean"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_anti_alias_quality
+++ observed/set_anti_alias_quality
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_blend_mode
+++ observed/set_blend_mode
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the video clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_clip_anchor_point
+++ observed/set_clip_anchor_point
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_clip_duration
+++ observed/set_clip_duration
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "include_linked": {
          "description": "Also apply the edit to the clip's linked audio/video partners, as Premiere does with linked selection (default: true).",
          "type": "boolean"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_clip_opacity
+++ observed/set_clip_opacity
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_clip_pan
+++ observed/set_clip_pan
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the audio clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_clip_position
+++ observed/set_clip_position
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_clip_properties
+++ observed/set_clip_properties
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_clip_properties_batch
+++ observed/set_clip_properties_batch
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "items": {
          "description": "Each item changes one or more supported opacity, Motion scale, position, or rotation values.",
          "items": {
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_clip_rotation
+++ observed/set_clip_rotation
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_clip_scale
+++ observed/set_clip_scale
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_clip_selection
+++ observed/set_clip_selection
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_clip_speed_qe
+++ observed/set_clip_speed_qe
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_clip_start_time
+++ observed/set_clip_start_time
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the project item",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_clip_volume
+++ observed/set_clip_volume
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the audio clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_clips_volume
+++ observed/set_clips_volume
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "track_index": {
          "description": "Audio track index (0-based)",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_color_label
+++ observed/set_color_label
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the project item",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_color_value
+++ observed/set_color_value
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_effect_property
+++ observed/set_effect_property
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_footage_interpretation
+++ observed/set_footage_interpretation
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the project item",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_frame_blend
+++ observed/set_frame_blend
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "node_id": {
          "description": "Node ID of the clip",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_graphics_white_luminance
+++ observed/set_graphics_white_luminance
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "luminance": {
          "description": "White luminance value in nits",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_item_in_out
+++ observed/set_item_in_out
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "in_seconds": {
          "description": "In point in seconds",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_keyframe_interpolation
+++ observed/set_keyframe_interpolation
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "interpolation": {
          "description": "Interpolation type",
          "enum": [
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_metadata
+++ observed/set_metadata
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the project item",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_offline
+++ observed/set_offline
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the project item",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_override_frame_rate
+++ observed/set_override_frame_rate
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the project item",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_override_pixel_aspect_ratio
+++ observed/set_override_pixel_aspect_ratio
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "item_id": {
          "description": "Node ID or name of the project item",
          "type": "string"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"

--- pinned/set_playhead_position
+++ observed/set_playhead_position
  {
    "annotations": {
      "destructiveHint": false,
+       "idempotency_key": {
+         "description": "Optional client-chosen key (1-128 chars of A-Z a-z 0-9 . _ : -) for this intended edit. Pass a fresh key per edit and reuse it only when retrying that same edit, for example after a client-side timeout. A repeat with the same tool, key and arguments is not run again: while the first call is running it fails with IDEMPOTENCY_IN_PROGRESS (poll get_last_operations); after it finished it returns the original outcome marked replayed. A definite failure with nothing applied (receipt outcome not_applied) may be retried with the same key. Reusing a key with different arguments fails with IDEMPOTENCY_KEY_REUSED. Scoped to this MCP session (the stdio server process or one HTTP session) and held in memory only (200 keys, 1 hour); it does not survive a restart or reconnect. Read-only invocations are never deduplicated.",
+         "maxLength": 128,
+         "minLength": 1,
+         "pattern": "^[A-Za-z0-9._:-]+$",
+         "type": "string"
+       },
        "time_seconds": {
          "description": "Time position in seconds to move the playhead to (0 to the sequence end)",
          "type": "number"
+       "idempotency": {
+         "additionalProperties": true,
+         "description": "Present when idempotency_key deduplicated this call: replayed is true when the original outcome was returned instead of running again.",
+         "type": "object"
+       },
        "ok": {
          "description": "Whether the tool completed successfully.",
          "type": "boolean"