premiere-pro-mcp 1.12.2 → 1.13.0

package/CHANGELOG.md

@@ -6,6 +6,25 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.13.0] - 2026-08-22
+
+### Added
+
+- Added `preview_project_intake`, a bounded, inspect-only project intake tool
+  that evaluates Premiere project organization against a facility-supplied
+  template and returns redacted findings plus proposed actions without changing
+  the project.
+- Added a deterministic intake rules engine, a guided workflow entry, a public
+  facts page, and design-partner/security pilot contracts for human-supervised
+  assistant-editor adoption.
+
+### Safety
+
+- File paths remain redacted unless explicitly requested, recursive capture and
+  outputs are bounded, and the intake workflow does not mutate or persist
+  project data. Automated tests passed, while licensed-host execution remains a
+  separate gate because Premiere 2026 hung before the CEP panel could open.
+
 ## [1.12.2] - 2026-08-22
 
 ### Fixed

package/README.md

@@ -6,7 +6,7 @@
 
 **Give compatible AI assistants structured control over supported Adobe Premiere Pro workflows.**
 
-287 core tools across 33 modules, 4 resources, and 10 guided workflows. A connected UXP host adds 50 capability-gated tools.
+288 core tools across 34 modules, 4 resources, and 11 guided workflows. A connected UXP host adds 50 capability-gated tools.
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![Node.js](https://img.shields.io/badge/Node.js-20.19%2B-green.svg)](https://nodejs.org)
@@ -29,9 +29,9 @@ An [MCP (Model Context Protocol)](https://modelcontextprotocol.io) server that l
 "Add the B-roll clips to V2, apply a cross dissolve between each, color correct them to match the A-roll, and export a 1080p ProRes."
 ```
 
-The AI handles the entire workflow through 287 core tools spanning the supported ExtendScript, QE DOM, revisioned project-context retrieval, safe edit-planning, and connection-verification surfaces. A compatible, authenticated UXP panel adds 50 documented, capability-gated tools without replacing the production CEP bridge.
+The AI handles the entire workflow through 288 core tools spanning the supported ExtendScript, QE DOM, revisioned project-context retrieval, safe edit-planning, project-intake preview, and connection-verification surfaces. A compatible, authenticated UXP panel adds 50 documented, capability-gated tools without replacing the production CEP bridge.
 
-### Latest release: 1.12.2
+### Latest release: 1.13.0
 
 - **MOGRT text and graphics:** `set_effect_property` now accepts string-backed
   parameters with safe serialization and readback status.
@@ -41,18 +41,32 @@ The AI handles the entire workflow through 287 core tools spanning the supported
 - **Verification clarity:** property readback remains distinct from playback or
   exported-frame verification in a licensed Premiere Pro host.
 
-See the [v1.12.2 release notes](https://github.com/leancoderkavy/premiere-pro-mcp/releases/tag/v1.12.2)
+See the [v1.13.0 release notes](https://github.com/leancoderkavy/premiere-pro-mcp/releases/tag/v1.13.0)
 for complete details. Live installation in Premiere Pro still requires host verification.
 
 ---
 
+## For editors evaluating an AI workflow
+
+Before an assistant changes an active project, use the
+[Premiere Pro AI workflow checklist](https://premiere-pro-mcp.com/blog/premiere-pro-ai-workflow-checklist/)
+to define the target and no-change boundaries, verify the local connection, request
+a bounded plan, and inspect the returned result. It is a practical starting point for
+assistant editors and post leads testing a repeatable workflow on a duplicate project
+or small test sequence.
+
+For product context, see the [Adobe Premiere AI Assistant and MCP comparison](https://premiere-pro-mcp.com/blog/adobe-premiere-ai-assistant-vs-mcp/)
+and the [Claude Desktop setup guide](https://premiere-pro-mcp.com/blog/claude-desktop-premiere-pro-mcp-setup/).
+
+---
+
 ## Quick Start
 
 ### Easiest supported path: Claude Desktop
 
-1. Download the current [Claude Desktop bundle (`.mcpb`)](https://github.com/leancoderkavy/premiere-pro-mcp/releases/download/v1.12.2/premiere-pro-mcp-1.12.2.mcpb).
+1. Download the current [Claude Desktop bundle (`.mcpb`)](https://github.com/leancoderkavy/premiere-pro-mcp/releases/download/v1.13.0/premiere-pro-mcp-1.13.0.mcpb).
 2. In Claude Desktop, open **Settings > Extensions > Advanced settings > Install Extension**, select the downloaded bundle, and restart Claude Desktop.
-3. Download the separate [signed Premiere connector (`.zxp`)](https://github.com/leancoderkavy/premiere-pro-mcp/releases/download/v1.12.2/MCPBridgeCEP.zxp). Open it with your trusted ZXP installer. If your computer has no ZXP installer, use the npm connector installer in **Advanced setup** below.
+3. Download the separate [signed Premiere connector (`.zxp`)](https://github.com/leancoderkavy/premiere-pro-mcp/releases/download/v1.13.0/MCPBridgeCEP.zxp). Open it with your trusted ZXP installer. If your computer has no ZXP installer, use the npm connector installer in **Advanced setup** below.
 4. Restart Premiere, open a project, then open **Window > Extensions > MCP for Adobe Premiere Pro**.
 5. In Claude, enter: `Safely check my Premiere connection with verify_premiere_connection. Make no changes.`
 
@@ -276,11 +290,11 @@ From a clone of this repository:
 ```bash
 codex plugin marketplace add .
 codex plugin add premiere-pro@premiere-pro-mcp
-npx -y premiere-pro-mcp@1.12.2 --install-cep
+npx -y premiere-pro-mcp@1.13.0 --install-cep
 ```
 
 Restart Premiere Pro and start a new Codex session after installation. The plugin
-launches `premiere-pro-mcp@1.12.2` through `npx`; the separate CEP installation is
+launches `premiere-pro-mcp@1.13.0` through `npx`; the separate CEP installation is
 required because the MCP server communicates with the running Premiere host through
 the local bridge.
 
@@ -300,7 +314,7 @@ For Claude Code, add this repository as a marketplace and install the plugin:
 Then install the Premiere bridge and start a new Claude Code session:
 
 ```bash
-npx -y premiere-pro-mcp@1.12.2 --install-cep
+npx -y premiere-pro-mcp@1.13.0 --install-cep
 ```
 
 The Claude Code package lives in
@@ -339,7 +353,7 @@ installed separately.
 QE-backed tools are reported as `experimental` because QE is undocumented and can vary between Premiere builds. Authority availability is reported separately from implementation support, so disabling `edit`, for example, does not incorrectly label editing tools as unsupported. Static metadata never claims that a Premiere operation succeeded; use `ping` and inspect each tool result for runtime evidence.
 
 MCP `tools/list` is filtered to the active authority profile. The default
-`inspect,edit,export,filesystem` profile advertises 285 of the 287 registered
+`inspect,edit,export,filesystem` profile advertises 286 of the 288 registered
 tools and omits `execute_extendscript` and `evaluate_expression`, which require
 explicit `unsafe-script` authority. `ping` and `get_capabilities` remain visible
 under every profile so a restricted or misconfigured server can still explain
@@ -494,7 +508,7 @@ The file-based IPC bridge is simple, reliable, and works across macOS and Window
 
 ---
 
-## Tools (287 core total; 285 under the default profile; 335 with a connected UXP bridge)
+## Tools (288 core total; 286 under the default profile; 336 with a connected UXP bridge)
 
 The [complete supported-actions catalog](docs/supported-actions.md) lists every
 registered core tool, the two tools restricted behind explicit `unsafe-script`
@@ -694,7 +708,7 @@ Track targeting, batch operations, markers, audio levels, motion/transform, meta
 
 ## MCP Resources
 
-The server exposes four LLM context resources and ten workflow prompts:
+The server exposes four LLM context resources and eleven workflow prompts:
 
 | Resource URI | Description |
 | :----------- | :---------- |
@@ -801,7 +815,7 @@ premiere-pro-mcp/
 ├── src/
 │   ├── index.ts                 # Entry point — stdio transport setup
 │   ├── http-server.ts           # Entry point — HTTP/SSE transport (Fly.io / remote)
-│   ├── server.ts                # MCP server — registers 287 tools, filtered by authority profile
+│   ├── server.ts                # MCP server — registers 288 tools, filtered by authority profile
 │   ├── bridge/
 │   │   ├── file-bridge.ts       # File-based IPC (write .jsx, poll .json)
 │   │   └── script-builder.ts    # ExtendScript generator with ES3 helpers

package/cep-plugin/CSXS/manifest.xml

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

package/cep-plugin/index.html

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

package/cep-plugin/updater.cjs

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

package/dist/http-server.js

@@ -89,8 +89,25 @@ function serveLanding(req, res, scriptNonce) {
         relativePath.startsWith(`..${path.sep}`) ||
         path.isAbsolute(relativePath))
         return false;
-    if (!fs.existsSync(filePath))
-        return false;
+    if (!fs.existsSync(filePath)) {
+        // Next static exports store dynamic-route Flight payloads in nested folders
+        // (for example, __next.blog/$d$slug/__PAGE__.txt), while the client asks
+        // for a flattened filename (__next.blog.$d$slug.__PAGE__.txt). Map only
+        // that generated shape after every original URL segment has passed the
+        // containment check above. Without this, guide-to-guide navigation falls
+        // back to a full-document load and emits avoidable 404s.
+        const requestedFlightFile = safeSegments.at(-1);
+        const flightParts = requestedFlightFile?.split(".") ?? [];
+        const isNestedFlightPayload = flightParts.length >= 4 &&
+            flightParts[0] === "__next" &&
+            flightParts.at(-1) === "txt";
+        if (!isNestedFlightPayload)
+            return false;
+        const remappedFlightPath = path.join(LANDING_DIR, ...safeSegments.slice(0, -1), `${flightParts[0]}.${flightParts[1]}`, ...flightParts.slice(2, -2), `${flightParts.at(-2)}.txt`);
+        if (!fs.existsSync(remappedFlightPath))
+            return false;
+        filePath = remappedFlightPath;
+    }
     let fileStats;
     try {
         fileStats = fs.statSync(filePath);

package/dist/index.js

@@ -21,7 +21,7 @@ function debugLog(message) {
 const args = process.argv.slice(2);
 if (args.includes("--help") || args.includes("-h")) {
     console.log(`
-premiere-pro-mcp — MCP server for Adobe Premiere Pro (285 default-profile tools)
+premiere-pro-mcp — MCP server for Adobe Premiere Pro (286 default-profile tools)
 
 Usage:
   premiere-pro-mcp              Start the MCP server (stdio transport)

package/dist/intake/project-intake.d.ts

@@ -0,0 +1,112 @@
+export declare const PROJECT_INTAKE_TEMPLATE_SCHEMA_VERSION = 1;
+export declare const PROJECT_INTAKE_REPORT_SCHEMA_VERSION = 1;
+export declare const MAX_PROJECT_INTAKE_ITEMS = 2000;
+export declare const MAX_PROJECT_INTAKE_RULES = 64;
+export declare const MAX_PROJECT_INTAKE_FINDINGS = 12200;
+export type IntakeCertainty = "observed" | "unavailable" | "not_checked";
+export type IntakeSeverity = "error" | "warning" | "info";
+export type IntakeStatus = "ready" | "needs_attention" | "incomplete";
+export interface RequiredBinRule {
+    name: string;
+    parentPath?: string;
+}
+export interface ApprovedPathPrefix {
+    id: string;
+    prefix: string;
+}
+export interface OrganizationMatchRule {
+    filenamePrefixes?: string[];
+    extensions?: string[];
+}
+export interface OrganizationRule {
+    id: string;
+    destinationBinName: string;
+    match: OrganizationMatchRule;
+    colorIndex?: number;
+}
+export interface FacilityIntakeTemplate {
+    schemaVersion: typeof PROJECT_INTAKE_TEMPLATE_SCHEMA_VERSION;
+    id: string;
+    version: string;
+    requiredBins: RequiredBinRule[];
+    allowedExtensions: string[];
+    allowedFrameRates: number[];
+    proxyPolicy: "ignore" | "report_missing" | "require";
+    approvedPathPrefixes: ApprovedPathPrefix[];
+    requiredEvidence: Array<"extension" | "frame_rate" | "offline" | "proxy" | "path">;
+    organizationRules: OrganizationRule[];
+}
+export interface ProjectIntakeItem {
+    id: string;
+    name: string;
+    type: "clip" | "bin" | "sequence" | "other";
+    parentId?: string;
+    treePath?: string;
+    mediaPath?: string;
+    offline?: boolean;
+    hasProxy?: boolean;
+    frameRate?: number;
+}
+export interface ProjectIntakeSnapshot {
+    project: {
+        id: string;
+        name?: string;
+    };
+    items: ProjectIntakeItem[];
+    truncated: boolean;
+    unavailableEvidence: string[];
+}
+export interface ProjectIntakeFinding {
+    code: string;
+    severity: IntakeSeverity;
+    certainty: IntakeCertainty;
+    itemId?: string;
+    expected?: Record<string, unknown>;
+    observed?: Record<string, unknown>;
+}
+export interface ProjectIntakeOrganizationPlan {
+    applied: false;
+    planDigest: string;
+    proposedBins: Array<{
+        name: string;
+        exists: boolean;
+        createIfApproved: boolean;
+    }>;
+    proposedMoves: Array<{
+        projectItemId: string;
+        expectedParentId?: string;
+        destinationBinName: string;
+        ruleId: string;
+        colorIndex?: number;
+    }>;
+}
+export interface ProjectIntakeReport {
+    schemaVersion: typeof PROJECT_INTAKE_REPORT_SCHEMA_VERSION;
+    applied: false;
+    status: IntakeStatus;
+    project: {
+        id: string;
+        name?: string;
+        revision: string;
+    };
+    template: {
+        id: string;
+        version: string;
+        digest: string;
+    };
+    capture: {
+        itemCount: number;
+        truncated: boolean;
+        pathDisclosure: "redacted" | "requested";
+    };
+    findings: ProjectIntakeFinding[];
+    organizationPlan: ProjectIntakeOrganizationPlan;
+    limitations: string[];
+}
+export interface BuildProjectIntakeOptions {
+    includePaths?: boolean;
+}
+export declare function validateFacilityIntakeTemplate(value: unknown): FacilityIntakeTemplate;
+export declare function validateProjectIntakeSnapshot(value: unknown): ProjectIntakeSnapshot;
+export declare function buildProjectIntakeReport(snapshotValue: unknown, templateValue: unknown, options?: BuildProjectIntakeOptions): ProjectIntakeReport;
+//# sourceMappingURL=project-intake.d.ts.map

package/dist/intake/project-intake.js

@@ -0,0 +1,555 @@
+import { createHash } from "node:crypto";
+export const PROJECT_INTAKE_TEMPLATE_SCHEMA_VERSION = 1;
+export const PROJECT_INTAKE_REPORT_SCHEMA_VERSION = 1;
+export const MAX_PROJECT_INTAKE_ITEMS = 2_000;
+export const MAX_PROJECT_INTAKE_RULES = 64;
+// A clip can produce six independent findings (extension, frame rate, offline,
+// proxy, path, and ambiguous organization), plus bounded project-level findings.
+export const MAX_PROJECT_INTAKE_FINDINGS = 12_200;
+const REQUIRED_EVIDENCE = new Set(["extension", "frame_rate", "offline", "proxy", "path"]);
+const ITEM_TYPES = new Set(["clip", "bin", "sequence", "other"]);
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(",")}]`;
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+}
+function digest(value) {
+    return sha256(stableStringify(value));
+}
+function asRecord(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error(`${label} must be an object`);
+    return value;
+}
+function assertOnlyKeys(record, allowed, label) {
+    for (const key of Object.keys(record)) {
+        if (!allowed.includes(key))
+            throw new Error(`${label}.${key} is not supported`);
+    }
+}
+function requiredText(value, label, maxLength) {
+    if (typeof value !== "string")
+        throw new Error(`${label} must be a string`);
+    const normalized = value.trim();
+    if (!normalized)
+        throw new Error(`${label} must not be empty`);
+    if (normalized.length > maxLength)
+        throw new Error(`${label} exceeds ${maxLength} characters`);
+    return normalized;
+}
+function optionalText(value, label, maxLength) {
+    if (value === undefined)
+        return undefined;
+    return requiredText(value, label, maxLength);
+}
+function optionalBoolean(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "boolean")
+        throw new Error(`${label} must be a boolean`);
+    return value;
+}
+function boundedArray(value, label, maxItems) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        throw new Error(`${label} must be an array`);
+    if (value.length > maxItems)
+        throw new Error(`${label} must contain at most ${maxItems} entries`);
+    return value;
+}
+function normalizeExtension(value, label) {
+    const extension = requiredText(value, label, 32).replace(/^\.+/, "").toLocaleLowerCase();
+    if (!/^[a-z0-9]{1,16}$/.test(extension))
+        throw new Error(`${label} must be a simple file extension`);
+    return extension;
+}
+function normalizeExtensions(value, label) {
+    const values = boundedArray(value, label, MAX_PROJECT_INTAKE_RULES);
+    const normalized = values.map((entry, index) => normalizeExtension(entry, `${label}[${index}]`));
+    if (new Set(normalized).size !== normalized.length)
+        throw new Error(`${label} contains duplicate extensions`);
+    return normalized.sort();
+}
+function normalizePrefixes(value, label) {
+    const values = boundedArray(value, label, MAX_PROJECT_INTAKE_RULES);
+    const normalized = values.map((entry, index) => requiredText(entry, `${label}[${index}]`, 255).toLocaleLowerCase());
+    if (new Set(normalized).size !== normalized.length)
+        throw new Error(`${label} contains duplicate filename prefixes`);
+    return normalized.sort();
+}
+function normalizeFrameRates(value, label) {
+    const values = boundedArray(value, label, MAX_PROJECT_INTAKE_RULES);
+    const normalized = values.map((entry, index) => {
+        if (typeof entry !== "number" || !Number.isFinite(entry) || entry < 1 || entry > 240) {
+            throw new Error(`${label}[${index}] must be a finite frame rate from 1 through 240`);
+        }
+        return Number(entry.toFixed(6));
+    });
+    if (new Set(normalized).size !== normalized.length)
+        throw new Error(`${label} contains duplicate frame rates`);
+    return normalized.sort((left, right) => left - right);
+}
+function normalizeTreePath(value) {
+    return value
+        .replace(/\\/g, "/")
+        .split("/")
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .join("/")
+        .toLocaleLowerCase();
+}
+function normalizeFilesystemPath(value) {
+    return value.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/\/+$/, "").toLocaleLowerCase();
+}
+function fileExtension(item) {
+    const source = item.mediaPath ?? item.name;
+    const leaf = source.replace(/\\/g, "/").split("/").at(-1) ?? "";
+    const index = leaf.lastIndexOf(".");
+    if (index <= 0 || index === leaf.length - 1)
+        return undefined;
+    const value = leaf.slice(index + 1).toLocaleLowerCase();
+    return /^[a-z0-9]{1,16}$/.test(value) ? value : undefined;
+}
+function parentTreePath(item) {
+    if (!item.treePath)
+        return undefined;
+    const path = normalizeTreePath(item.treePath);
+    const parts = path.split("/");
+    if (parts.at(-1) === item.name.trim().toLocaleLowerCase())
+        parts.pop();
+    return parts.join("/") || undefined;
+}
+function pathEvidence(mediaPath, includePaths) {
+    return {
+        mediaPathHash: sha256(normalizeFilesystemPath(mediaPath)),
+        ...(includePaths ? { mediaPath } : {}),
+    };
+}
+function isRequired(template, evidence) {
+    return template.requiredEvidence.includes(evidence)
+        || (evidence === "extension" && template.allowedExtensions.length > 0)
+        || (evidence === "frame_rate" && template.allowedFrameRates.length > 0)
+        || (evidence === "proxy" && template.proxyPolicy === "require")
+        || (evidence === "path" && template.approvedPathPrefixes.length > 0);
+}
+function findingSort(left, right) {
+    const severity = { error: 0, warning: 1, info: 2 };
+    return severity[left.severity] - severity[right.severity]
+        || left.code.localeCompare(right.code)
+        || (left.itemId ?? "").localeCompare(right.itemId ?? "")
+        || stableStringify(left.expected).localeCompare(stableStringify(right.expected));
+}
+function pushFinding(findings, finding) {
+    if (findings.length >= MAX_PROJECT_INTAKE_FINDINGS)
+        return;
+    findings.push(finding);
+}
+export function validateFacilityIntakeTemplate(value) {
+    const input = asRecord(value, "template");
+    assertOnlyKeys(input, [
+        "schemaVersion", "id", "version", "requiredBins", "allowedExtensions", "allowedFrameRates",
+        "proxyPolicy", "approvedPathPrefixes", "requiredEvidence", "organizationRules",
+    ], "template");
+    if (input.schemaVersion !== PROJECT_INTAKE_TEMPLATE_SCHEMA_VERSION) {
+        throw new Error(`template.schemaVersion must be ${PROJECT_INTAKE_TEMPLATE_SCHEMA_VERSION}`);
+    }
+    const requiredBins = boundedArray(input.requiredBins, "template.requiredBins", MAX_PROJECT_INTAKE_RULES).map((entry, index) => {
+        const rule = asRecord(entry, `template.requiredBins[${index}]`);
+        assertOnlyKeys(rule, ["name", "parentPath"], `template.requiredBins[${index}]`);
+        return {
+            name: requiredText(rule.name, `template.requiredBins[${index}].name`, 255),
+            ...(optionalText(rule.parentPath, `template.requiredBins[${index}].parentPath`, 1024) ? {
+                parentPath: optionalText(rule.parentPath, `template.requiredBins[${index}].parentPath`, 1024),
+            } : {}),
+        };
+    });
+    const binKeys = requiredBins.map((rule) => `${normalizeTreePath(rule.parentPath ?? "")}\u0000${rule.name.toLocaleLowerCase()}`);
+    if (new Set(binKeys).size !== binKeys.length)
+        throw new Error("template.requiredBins contains duplicate bin requirements");
+    const approvedPathPrefixes = boundedArray(input.approvedPathPrefixes, "template.approvedPathPrefixes", MAX_PROJECT_INTAKE_RULES).map((entry, index) => {
+        const prefix = asRecord(entry, `template.approvedPathPrefixes[${index}]`);
+        assertOnlyKeys(prefix, ["id", "prefix"], `template.approvedPathPrefixes[${index}]`);
+        return {
+            id: requiredText(prefix.id, `template.approvedPathPrefixes[${index}].id`, 128),
+            prefix: requiredText(prefix.prefix, `template.approvedPathPrefixes[${index}].prefix`, 4096),
+        };
+    });
+    if (new Set(approvedPathPrefixes.map((prefix) => prefix.id)).size !== approvedPathPrefixes.length) {
+        throw new Error("template.approvedPathPrefixes contains duplicate ids");
+    }
+    const requiredEvidence = boundedArray(input.requiredEvidence, "template.requiredEvidence", 5).map((entry, index) => {
+        if (typeof entry !== "string" || !REQUIRED_EVIDENCE.has(entry)) {
+            throw new Error(`template.requiredEvidence[${index}] must be extension, frame_rate, offline, proxy, or path`);
+        }
+        return entry;
+    });
+    if (new Set(requiredEvidence).size !== requiredEvidence.length)
+        throw new Error("template.requiredEvidence contains duplicate entries");
+    const organizationRules = boundedArray(input.organizationRules, "template.organizationRules", MAX_PROJECT_INTAKE_RULES).map((entry, index) => {
+        const rule = asRecord(entry, `template.organizationRules[${index}]`);
+        assertOnlyKeys(rule, ["id", "destinationBinName", "match", "colorIndex"], `template.organizationRules[${index}]`);
+        const match = asRecord(rule.match, `template.organizationRules[${index}].match`);
+        assertOnlyKeys(match, ["filenamePrefixes", "extensions"], `template.organizationRules[${index}].match`);
+        const filenamePrefixes = normalizePrefixes(match.filenamePrefixes, `template.organizationRules[${index}].match.filenamePrefixes`);
+        const extensions = normalizeExtensions(match.extensions, `template.organizationRules[${index}].match.extensions`);
+        if (!filenamePrefixes.length && !extensions.length) {
+            throw new Error(`template.organizationRules[${index}].match must include a filename prefix or extension`);
+        }
+        const colorIndex = rule.colorIndex;
+        if (colorIndex !== undefined && (!Number.isInteger(colorIndex) || typeof colorIndex !== "number" || colorIndex < 0 || colorIndex > 14)) {
+            throw new Error(`template.organizationRules[${index}].colorIndex must be an integer from 0 through 14`);
+        }
+        return {
+            id: requiredText(rule.id, `template.organizationRules[${index}].id`, 128),
+            destinationBinName: requiredText(rule.destinationBinName, `template.organizationRules[${index}].destinationBinName`, 255),
+            match: {
+                ...(filenamePrefixes.length ? { filenamePrefixes } : {}),
+                ...(extensions.length ? { extensions } : {}),
+            },
+            ...(colorIndex === undefined ? {} : { colorIndex }),
+        };
+    });
+    if (new Set(organizationRules.map((rule) => rule.id)).size !== organizationRules.length) {
+        throw new Error("template.organizationRules contains duplicate ids");
+    }
+    const proxyPolicy = input.proxyPolicy === undefined ? "ignore" : input.proxyPolicy;
+    if (proxyPolicy !== "ignore" && proxyPolicy !== "report_missing" && proxyPolicy !== "require") {
+        throw new Error("template.proxyPolicy must be ignore, report_missing, or require");
+    }
+    return {
+        schemaVersion: PROJECT_INTAKE_TEMPLATE_SCHEMA_VERSION,
+        id: requiredText(input.id, "template.id", 128),
+        version: requiredText(input.version, "template.version", 128),
+        requiredBins: requiredBins.sort((left, right) => `${left.parentPath ?? ""}/${left.name}`.localeCompare(`${right.parentPath ?? ""}/${right.name}`)),
+        allowedExtensions: normalizeExtensions(input.allowedExtensions, "template.allowedExtensions"),
+        allowedFrameRates: normalizeFrameRates(input.allowedFrameRates, "template.allowedFrameRates"),
+        proxyPolicy,
+        approvedPathPrefixes: approvedPathPrefixes.sort((left, right) => left.id.localeCompare(right.id)),
+        requiredEvidence: requiredEvidence.sort(),
+        organizationRules: organizationRules.sort((left, right) => left.id.localeCompare(right.id)),
+    };
+}
+export function validateProjectIntakeSnapshot(value) {
+    const input = asRecord(value, "snapshot");
+    assertOnlyKeys(input, ["project", "items", "truncated", "unavailableEvidence"], "snapshot");
+    const project = asRecord(input.project, "snapshot.project");
+    assertOnlyKeys(project, ["id", "name"], "snapshot.project");
+    const items = boundedArray(input.items, "snapshot.items", MAX_PROJECT_INTAKE_ITEMS).map((entry, index) => {
+        const item = asRecord(entry, `snapshot.items[${index}]`);
+        assertOnlyKeys(item, ["id", "name", "type", "parentId", "treePath", "mediaPath", "offline", "hasProxy", "frameRate"], `snapshot.items[${index}]`);
+        if (typeof item.type !== "string" || !ITEM_TYPES.has(item.type)) {
+            throw new Error(`snapshot.items[${index}].type must be clip, bin, sequence, or other`);
+        }
+        if (item.frameRate !== undefined && (typeof item.frameRate !== "number" || !Number.isFinite(item.frameRate) || item.frameRate < 1 || item.frameRate > 240)) {
+            throw new Error(`snapshot.items[${index}].frameRate must be a finite frame rate from 1 through 240`);
+        }
+        return {
+            id: requiredText(item.id, `snapshot.items[${index}].id`, 512),
+            name: requiredText(item.name, `snapshot.items[${index}].name`, 255),
+            type: item.type,
+            ...(optionalText(item.parentId, `snapshot.items[${index}].parentId`, 512) ? { parentId: optionalText(item.parentId, `snapshot.items[${index}].parentId`, 512) } : {}),
+            ...(optionalText(item.treePath, `snapshot.items[${index}].treePath`, 4096) ? { treePath: optionalText(item.treePath, `snapshot.items[${index}].treePath`, 4096) } : {}),
+            ...(optionalText(item.mediaPath, `snapshot.items[${index}].mediaPath`, 4096) ? { mediaPath: optionalText(item.mediaPath, `snapshot.items[${index}].mediaPath`, 4096) } : {}),
+            ...(optionalBoolean(item.offline, `snapshot.items[${index}].offline`) === undefined ? {} : { offline: optionalBoolean(item.offline, `snapshot.items[${index}].offline`) }),
+            ...(optionalBoolean(item.hasProxy, `snapshot.items[${index}].hasProxy`) === undefined ? {} : { hasProxy: optionalBoolean(item.hasProxy, `snapshot.items[${index}].hasProxy`) }),
+            ...(item.frameRate === undefined ? {} : { frameRate: Number(item.frameRate.toFixed(6)) }),
+        };
+    });
+    if (new Set(items.map((item) => item.id)).size !== items.length)
+        throw new Error("snapshot.items contains duplicate ids");
+    const unavailableEvidence = boundedArray(input.unavailableEvidence, "snapshot.unavailableEvidence", MAX_PROJECT_INTAKE_RULES).map((entry, index) => requiredText(entry, `snapshot.unavailableEvidence[${index}]`, 128));
+    if (new Set(unavailableEvidence).size !== unavailableEvidence.length)
+        throw new Error("snapshot.unavailableEvidence contains duplicate entries");
+    if (typeof input.truncated !== "boolean")
+        throw new Error("snapshot.truncated must be a boolean");
+    return {
+        project: {
+            id: requiredText(project.id, "snapshot.project.id", 512),
+            ...(optionalText(project.name, "snapshot.project.name", 255) ? { name: optionalText(project.name, "snapshot.project.name", 255) } : {}),
+        },
+        items: items.sort((left, right) => left.id.localeCompare(right.id)),
+        truncated: input.truncated,
+        unavailableEvidence: unavailableEvidence.sort(),
+    };
+}
+function ruleMatches(item, rule) {
+    const name = item.name.toLocaleLowerCase();
+    const extension = fileExtension(item);
+    const prefixes = rule.match.filenamePrefixes ?? [];
+    const extensions = rule.match.extensions ?? [];
+    return (!prefixes.length || prefixes.some((prefix) => name.startsWith(prefix)))
+        && (!extensions.length || (extension !== undefined && extensions.includes(extension)));
+}
+export function buildProjectIntakeReport(snapshotValue, templateValue, options = {}) {
+    const snapshot = validateProjectIntakeSnapshot(snapshotValue);
+    const template = validateFacilityIntakeTemplate(templateValue);
+    const includePaths = options.includePaths === true;
+    const templateDigest = digest(template);
+    const projectRevision = digest(snapshot);
+    const findings = [];
+    const requiredUnavailable = new Set();
+    if (snapshot.truncated) {
+        pushFinding(findings, {
+            code: "CAPTURE_TRUNCATED",
+            severity: "error",
+            certainty: "unavailable",
+            expected: { maximumItems: MAX_PROJECT_INTAKE_ITEMS },
+            observed: { itemCount: snapshot.items.length },
+        });
+    }
+    for (const evidence of snapshot.unavailableEvidence) {
+        const normalized = evidence.toLocaleLowerCase();
+        if (REQUIRED_EVIDENCE.has(normalized) && isRequired(template, normalized)) {
+            requiredUnavailable.add(normalized);
+            pushFinding(findings, {
+                code: "REQUIRED_EVIDENCE_UNAVAILABLE",
+                severity: "error",
+                certainty: "unavailable",
+                expected: { evidence: normalized },
+            });
+        }
+    }
+    const bins = snapshot.items.filter((item) => item.type === "bin");
+    for (const rule of template.requiredBins) {
+        const nameMatches = bins.filter((item) => item.name.toLocaleLowerCase() === rule.name.toLocaleLowerCase());
+        if (!nameMatches.length) {
+            pushFinding(findings, {
+                code: "REQUIRED_BIN_MISSING",
+                severity: "error",
+                certainty: "observed",
+                expected: { name: rule.name, ...(rule.parentPath ? { parentPath: rule.parentPath } : {}) },
+            });
+            continue;
+        }
+        if (!rule.parentPath)
+            continue;
+        const expectedParent = normalizeTreePath(rule.parentPath);
+        const pathKnown = nameMatches.some((item) => parentTreePath(item) !== undefined);
+        const parentMatches = nameMatches.filter((item) => {
+            const parent = parentTreePath(item);
+            return parent === expectedParent || parent?.endsWith(`/${expectedParent}`) === true;
+        });
+        if (parentMatches.length)
+            continue;
+        if (!pathKnown) {
+            requiredUnavailable.add("bin_parent_path");
+            pushFinding(findings, {
+                code: "REQUIRED_BIN_PARENT_UNAVAILABLE",
+                severity: "error",
+                certainty: "unavailable",
+                expected: { name: rule.name, parentPath: rule.parentPath },
+            });
+        }
+        else {
+            pushFinding(findings, {
+                code: "REQUIRED_BIN_WRONG_PARENT",
+                severity: "error",
+                certainty: "observed",
+                expected: { name: rule.name, parentPath: rule.parentPath },
+                observed: { matchingBinIds: nameMatches.map((item) => item.id).sort() },
+            });
+        }
+    }
+    const clips = snapshot.items.filter((item) => item.type === "clip");
+    for (const item of clips) {
+        const extension = fileExtension(item);
+        if (template.allowedExtensions.length || isRequired(template, "extension")) {
+            if (!extension) {
+                requiredUnavailable.add("extension");
+                pushFinding(findings, {
+                    code: "EXTENSION_UNAVAILABLE",
+                    severity: "error",
+                    certainty: "unavailable",
+                    itemId: item.id,
+                    expected: { allowedExtensions: template.allowedExtensions },
+                });
+            }
+            else if (!template.allowedExtensions.includes(extension)) {
+                pushFinding(findings, {
+                    code: "EXTENSION_NOT_ALLOWED",
+                    severity: "error",
+                    certainty: "observed",
+                    itemId: item.id,
+                    expected: { allowedExtensions: template.allowedExtensions },
+                    observed: { extension },
+                });
+            }
+        }
+        if (template.allowedFrameRates.length || isRequired(template, "frame_rate")) {
+            if (item.frameRate === undefined) {
+                requiredUnavailable.add("frame_rate");
+                pushFinding(findings, {
+                    code: "FRAME_RATE_UNAVAILABLE",
+                    severity: "error",
+                    certainty: "unavailable",
+                    itemId: item.id,
+                    expected: { allowedFrameRates: template.allowedFrameRates },
+                });
+            }
+            else if (!template.allowedFrameRates.some((rate) => Math.abs(rate - item.frameRate) <= 0.000001)) {
+                pushFinding(findings, {
+                    code: "FRAME_RATE_NOT_ALLOWED",
+                    severity: "error",
+                    certainty: "observed",
+                    itemId: item.id,
+                    expected: { allowedFrameRates: template.allowedFrameRates },
+                    observed: { frameRate: item.frameRate },
+                });
+            }
+        }
+        if (item.offline === true) {
+            pushFinding(findings, {
+                code: "OFFLINE_MEDIA",
+                severity: "error",
+                certainty: "observed",
+                itemId: item.id,
+                observed: { offline: true },
+            });
+        }
+        else if (item.offline === undefined && isRequired(template, "offline")) {
+            requiredUnavailable.add("offline");
+            pushFinding(findings, {
+                code: "OFFLINE_STATE_UNAVAILABLE",
+                severity: "error",
+                certainty: "unavailable",
+                itemId: item.id,
+            });
+        }
+        if (template.proxyPolicy !== "ignore" || isRequired(template, "proxy")) {
+            if (item.hasProxy === false) {
+                pushFinding(findings, {
+                    code: "PROXY_MISSING",
+                    severity: template.proxyPolicy === "require" ? "error" : "warning",
+                    certainty: "observed",
+                    itemId: item.id,
+                    expected: { proxyPolicy: template.proxyPolicy },
+                    observed: { hasProxy: false },
+                });
+            }
+            else if (item.hasProxy === undefined) {
+                if (template.proxyPolicy === "require" || isRequired(template, "proxy")) {
+                    requiredUnavailable.add("proxy");
+                    pushFinding(findings, {
+                        code: "PROXY_STATE_UNAVAILABLE",
+                        severity: "error",
+                        certainty: "unavailable",
+                        itemId: item.id,
+                        expected: { proxyPolicy: template.proxyPolicy },
+                    });
+                }
+                else {
+                    pushFinding(findings, {
+                        code: "PROXY_STATE_NOT_CHECKED",
+                        severity: "info",
+                        certainty: "not_checked",
+                        itemId: item.id,
+                    });
+                }
+            }
+        }
+        if (template.approvedPathPrefixes.length || isRequired(template, "path")) {
+            if (!item.mediaPath) {
+                requiredUnavailable.add("path");
+                pushFinding(findings, {
+                    code: "MEDIA_PATH_UNAVAILABLE",
+                    severity: "error",
+                    certainty: "unavailable",
+                    itemId: item.id,
+                    expected: { approvedPathPrefixIds: template.approvedPathPrefixes.map((prefix) => prefix.id) },
+                });
+            }
+            else {
+                const normalizedPath = normalizeFilesystemPath(item.mediaPath);
+                const matches = template.approvedPathPrefixes.filter((prefix) => normalizedPath === normalizeFilesystemPath(prefix.prefix)
+                    || normalizedPath.startsWith(`${normalizeFilesystemPath(prefix.prefix)}/`));
+                if (!matches.length) {
+                    pushFinding(findings, {
+                        code: "MEDIA_PATH_NOT_APPROVED",
+                        severity: "error",
+                        certainty: "observed",
+                        itemId: item.id,
+                        expected: { approvedPathPrefixIds: template.approvedPathPrefixes.map((prefix) => prefix.id) },
+                        observed: pathEvidence(item.mediaPath, includePaths),
+                    });
+                }
+            }
+        }
+    }
+    const existingBinNames = new Set(bins.map((item) => item.name.toLocaleLowerCase()));
+    const proposedMoves = [];
+    for (const item of clips) {
+        const matches = template.organizationRules.filter((rule) => ruleMatches(item, rule));
+        if (matches.length > 1) {
+            pushFinding(findings, {
+                code: "AMBIGUOUS_ORGANIZATION_RULES",
+                severity: "warning",
+                certainty: "observed",
+                itemId: item.id,
+                observed: { matchingRuleIds: matches.map((rule) => rule.id).sort() },
+            });
+            continue;
+        }
+        const rule = matches[0];
+        if (!rule)
+            continue;
+        proposedMoves.push({
+            projectItemId: item.id,
+            ...(item.parentId ? { expectedParentId: item.parentId } : {}),
+            destinationBinName: rule.destinationBinName,
+            ruleId: rule.id,
+            ...(rule.colorIndex === undefined ? {} : { colorIndex: rule.colorIndex }),
+        });
+    }
+    proposedMoves.sort((left, right) => left.projectItemId.localeCompare(right.projectItemId));
+    const proposedBins = [...new Set(proposedMoves.map((move) => move.destinationBinName))]
+        .sort((left, right) => left.localeCompare(right))
+        .map((name) => ({
+        name,
+        exists: existingBinNames.has(name.toLocaleLowerCase()),
+        createIfApproved: !existingBinNames.has(name.toLocaleLowerCase()),
+    }));
+    const planDigest = digest({ templateDigest, projectRevision, proposedBins, proposedMoves });
+    findings.sort(findingSort);
+    const incomplete = snapshot.truncated || requiredUnavailable.size > 0;
+    const status = incomplete
+        ? "incomplete"
+        : findings.some((finding) => finding.severity === "error" || finding.severity === "warning")
+            ? "needs_attention"
+            : "ready";
+    return {
+        schemaVersion: PROJECT_INTAKE_REPORT_SCHEMA_VERSION,
+        applied: false,
+        status,
+        project: {
+            id: snapshot.project.id,
+            ...(snapshot.project.name ? { name: snapshot.project.name } : {}),
+            revision: projectRevision,
+        },
+        template: { id: template.id, version: template.version, digest: templateDigest },
+        capture: {
+            itemCount: snapshot.items.length,
+            truncated: snapshot.truncated,
+            pathDisclosure: includePaths ? "requested" : "redacted",
+        },
+        findings,
+        organizationPlan: {
+            applied: false,
+            planDigest,
+            proposedBins,
+            proposedMoves,
+        },
+        limitations: [
+            "This is a read-only plan. It does not create bins, rename items, move media, apply labels, or change Premiere.",
+            ...(snapshot.truncated ? ["The project capture was truncated, so this report is incomplete."] : []),
+            ...(requiredUnavailable.size ? ["Required host evidence was unavailable; inspect the affected items before using this report for compliance decisions."] : []),
+        ],
+    };
+}
+//# sourceMappingURL=project-intake.js.map

package/dist/security/capabilities.js

@@ -47,6 +47,7 @@ const INSPECT_TOOL_NAMES = new Set([
     "create_context_edit_plan",
     "create_editorial_plan",
     "preview_editorial_plan",
+    "preview_project_intake",
 ]);
 // detect_silence reads a media file from disk and shells out to ffmpeg. It
 // changes nothing in Premiere, so classifying it as "edit" would overstate what

package/dist/server.js

@@ -32,6 +32,7 @@ import { getAvSettingsTools } from "./tools/av-settings.js";
 import { getRecoveryTools } from "./tools/recovery.js";
 import { getProjectContextTools } from "./tools/project-context.js";
 import { getEditorialPlanTools } from "./tools/editorial-plans.js";
+import { getProjectIntakeTools } from "./tools/project-intake.js";
 import { getUxpTools } from "./tools/uxp.js";
 import { guardToolHandler, isToolPermitted, resolveCapabilities, } from "./security/index.js";
 import { EXTENDSCRIPT_REFERENCE } from "./resources/extendscript-reference.js";
@@ -240,6 +241,7 @@ function collectTools(bridgeOptions, capabilities, uxpBridge, telemetry, cacheab
         ...getRecoveryTools(bridgeOptions),
         ...getProjectContextTools(bridgeOptions),
         ...getEditorialPlanTools({ uxpBridge }),
+        ...getProjectIntakeTools(bridgeOptions),
         ...(uxpBridge ? getUxpTools(uxpBridge) : {}),
     };
     Object.assign(tools, getHealthTools(bridgeOptions, capabilities, () => tools, {

package/dist/tools/project-intake.d.ts

@@ -0,0 +1,41 @@
+import { type BridgeOptions, type CommandResult } from "../bridge/file-bridge.js";
+export interface ProjectIntakeToolDependencies {
+    captureSnapshot?: (maxItems: number) => Promise<CommandResult>;
+}
+/**
+ * Capture only the bounded fields required by the pure intake evaluator. The
+ * script does not require an active sequence and never changes Premiere.
+ */
+export declare function projectIntakeCaptureScript(maxItems: number): string;
+export declare function getProjectIntakeTools(bridgeOptions: BridgeOptions, dependencies?: ProjectIntakeToolDependencies): {
+    preview_project_intake: {
+        description: string;
+        parameters: {
+            type: "object";
+            additionalProperties: boolean;
+            properties: {
+                template: {
+                    type: string;
+                    description: string;
+                };
+                include_paths: {
+                    type: string;
+                    description: string;
+                };
+                max_items: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        handler: (args: {
+            template: unknown;
+            include_paths?: boolean;
+            max_items?: number;
+        }) => Promise<CommandResult>;
+    };
+};
+//# sourceMappingURL=project-intake.d.ts.map

package/dist/tools/project-intake.js

@@ -0,0 +1,120 @@
+import { buildToolScript } from "../bridge/script-builder.js";
+import { sendCommand } from "../bridge/file-bridge.js";
+import { buildProjectIntakeReport, MAX_PROJECT_INTAKE_ITEMS, } from "../intake/project-intake.js";
+function boundedMaxItems(value) {
+    if (value === undefined)
+        return MAX_PROJECT_INTAKE_ITEMS;
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > MAX_PROJECT_INTAKE_ITEMS) {
+        throw new Error(`max_items must be an integer from 1 through ${MAX_PROJECT_INTAKE_ITEMS}`);
+    }
+    return value;
+}
+/**
+ * Capture only the bounded fields required by the pure intake evaluator. The
+ * script does not require an active sequence and never changes Premiere.
+ */
+export function projectIntakeCaptureScript(maxItems) {
+    return buildToolScript(`
+    var project = app.project;
+    if (!project || !project.rootItem) return __error("No project is open");
+
+    var maximumItems = ${maxItems};
+    var items = [];
+    var truncated = false;
+
+    function itemType(item) {
+      if (item.type === 2) return "bin";
+      if (item.type === 1 || item.type === 4) return "clip";
+      return "other";
+    }
+
+    function walk(parent, parentId, depth) {
+      if (!parent || !parent.children || depth > 32) {
+        if (depth > 32) truncated = true;
+        return;
+      }
+      for (var i = 0; i < parent.children.numItems; i++) {
+        if (items.length >= maximumItems) { truncated = true; return; }
+        var item = parent.children[i];
+        var entry = {
+          id: String(item.nodeId),
+          name: String(item.name),
+          type: itemType(item),
+          parentId: String(parentId || "root")
+        };
+        try { if (item.treePath) entry.treePath = String(item.treePath); } catch(e) {}
+        try {
+          var mediaPath = item.getMediaPath();
+          if (mediaPath) entry.mediaPath = String(mediaPath);
+        } catch(e) {}
+        try { entry.offline = Boolean(item.isOffline()); } catch(e) {}
+        try { entry.hasProxy = Boolean(item.hasProxy()); } catch(e) {}
+        try {
+          var interpretation = item.getFootageInterpretation();
+          if (interpretation && interpretation.frameRate) entry.frameRate = Number(interpretation.frameRate);
+        } catch(e) {}
+        items.push(entry);
+        if (item.type === 2) walk(item, item.nodeId, depth + 1);
+        if (truncated && items.length >= maximumItems) return;
+      }
+    }
+
+    walk(project.rootItem, "root", 0);
+    var projectId = "";
+    try { if (project.documentID) projectId = String(project.documentID); } catch(e) {}
+    if (!projectId) projectId = String(project.name);
+
+    return __result({
+      project: { id: projectId, name: String(project.name) },
+      items: items,
+      truncated: truncated,
+      unavailableEvidence: []
+    });
+  `);
+}
+export function getProjectIntakeTools(bridgeOptions, dependencies = {}) {
+    const capture = dependencies.captureSnapshot
+        ?? ((maxItems) => sendCommand(projectIntakeCaptureScript(maxItems), bridgeOptions));
+    return {
+        preview_project_intake: {
+            description: "Inspect a bounded Premiere project against an explicit facility intake template and return a path-redacted report plus a non-mutating organization proposal. It never changes Premiere or persists the template.",
+            parameters: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    template: {
+                        type: "object",
+                        description: "Versioned facility policy. Unknown fields and unsafe matching expressions are rejected by the intake engine.",
+                    },
+                    include_paths: {
+                        type: "boolean",
+                        description: "Include observed media paths in findings. Defaults to false; hashes are returned instead.",
+                    },
+                    max_items: {
+                        type: "integer",
+                        minimum: 1,
+                        maximum: MAX_PROJECT_INTAKE_ITEMS,
+                        description: `Maximum project items to inspect; defaults to ${MAX_PROJECT_INTAKE_ITEMS}. Truncation returns an incomplete report.`,
+                    },
+                },
+                required: ["template"],
+            },
+            handler: async (args) => {
+                try {
+                    const maxItems = boundedMaxItems(args.max_items);
+                    const captured = await capture(maxItems);
+                    if (!captured.success)
+                        return captured;
+                    return {
+                        success: true,
+                        data: buildProjectIntakeReport(captured.data, args.template, { includePaths: args.include_paths === true }),
+                    };
+                }
+                catch (error) {
+                    return { success: false, error: error instanceof Error ? error.message : String(error) };
+                }
+            },
+        },
+    };
+}
+//# sourceMappingURL=project-intake.js.map

package/dist/workflows/catalog.d.ts

@@ -4,6 +4,11 @@ export declare const WORKFLOW_CATALOG: readonly [{
     readonly title: "Assemble a rough cut";
     readonly summary: "Inspect the project, import media, create or select a sequence, assemble clips, then verify and save.";
     readonly recommendedTools: readonly ["get_premiere_state", "import_media", "create_sequence", "add_to_timeline", "get_sequence_structure", "save_project"];
+}, {
+    readonly id: "project-intake";
+    readonly title: "Preview project intake";
+    readonly summary: "Inspect a bounded project against an explicit facility template and return a path-redacted intake report and non-mutating organization proposal.";
+    readonly recommendedTools: readonly ["verify_premiere_connection", "preview_project_intake"];
 }, {
     readonly id: "dialogue-cleanup";
     readonly title: "Clean up dialogue";
@@ -53,8 +58,8 @@ export declare const WORKFLOW_CATALOG: readonly [{
 export declare const WORKFLOW_RESOURCE: string;
 export declare const WORKFLOW_PROMPTS: {
     name: string;
-    title: "Assemble a rough cut" | "Clean up dialogue" | "Caption and style a sequence" | "Prepare a delivery export" | "Build a context-aware rough cut" | "Plan a transcript-driven rough cut" | "Plan project organization" | "Plan a reviewed stringout" | "Review a caption artifact" | "Plan platform cutdowns";
-    description: "Inspect the project, import media, create or select a sequence, assemble clips, then verify and save." | "Inspect audio tracks, normalize dialogue, apply conservative cleanup, and verify levels before saving." | "Inspect the active sequence, create captions, apply styling, verify timing, and save." | "Validate the sequence and destination, export with an explicit preset, then report the produced artifact." | "Capture reusable project context, retrieve only evidence relevant to the edit intent, create a revision-guarded plan, then preview before applying." | "Export Premiere's native transcript, select revision-locked source ranges, map them to verified 1x placements in a duplicate sequence, then execute the descending cut plan with re-query verification." | "Capture project context, supply explicit editorial categories, create and preview a review-only organization plan, then use its guarded apply route with stable-ID bin operations. Direct organize_project_items_uxp use is advanced/manual only." | "Retrieve relevant local evidence, produce a review-only stringout plan, resolve selected project items, then create and verify a new sequence." | "Use existing transcript evidence to review a supplied caption artifact, import it deliberately, create a caption track, and verify playback before delivery." | "Capture source-sequence context, propose bounded platform dimensions, review derivative sequence routes, then create and verify each cutdown deliberately.";
+    title: "Assemble a rough cut" | "Preview project intake" | "Clean up dialogue" | "Caption and style a sequence" | "Prepare a delivery export" | "Build a context-aware rough cut" | "Plan a transcript-driven rough cut" | "Plan project organization" | "Plan a reviewed stringout" | "Review a caption artifact" | "Plan platform cutdowns";
+    description: "Inspect the project, import media, create or select a sequence, assemble clips, then verify and save." | "Inspect a bounded project against an explicit facility template and return a path-redacted intake report and non-mutating organization proposal." | "Inspect audio tracks, normalize dialogue, apply conservative cleanup, and verify levels before saving." | "Inspect the active sequence, create captions, apply styling, verify timing, and save." | "Validate the sequence and destination, export with an explicit preset, then report the produced artifact." | "Capture reusable project context, retrieve only evidence relevant to the edit intent, create a revision-guarded plan, then preview before applying." | "Export Premiere's native transcript, select revision-locked source ranges, map them to verified 1x placements in a duplicate sequence, then execute the descending cut plan with re-query verification." | "Capture project context, supply explicit editorial categories, create and preview a review-only organization plan, then use its guarded apply route with stable-ID bin operations. Direct organize_project_items_uxp use is advanced/manual only." | "Retrieve relevant local evidence, produce a review-only stringout plan, resolve selected project items, then create and verify a new sequence." | "Use existing transcript evidence to review a supplied caption artifact, import it deliberately, create a caption track, and verify playback before delivery." | "Capture source-sequence context, propose bounded platform dimensions, review derivative sequence routes, then create and verify each cutdown deliberately.";
     argsSchema: {
         goal: z.ZodString;
         constraints: z.ZodOptional<z.ZodString>;

package/dist/workflows/catalog.js

@@ -6,6 +6,12 @@ export const WORKFLOW_CATALOG = [
         summary: "Inspect the project, import media, create or select a sequence, assemble clips, then verify and save.",
         recommendedTools: ["get_premiere_state", "import_media", "create_sequence", "add_to_timeline", "get_sequence_structure", "save_project"],
     },
+    {
+        id: "project-intake",
+        title: "Preview project intake",
+        summary: "Inspect a bounded project against an explicit facility template and return a path-redacted intake report and non-mutating organization proposal.",
+        recommendedTools: ["verify_premiere_connection", "preview_project_intake"],
+    },
     {
         id: "dialogue-cleanup",
         title: "Clean up dialogue",

package/dist/workflows/tool-metadata.js

@@ -3,6 +3,7 @@ const READ_ONLY_TOOLS = new Set([
     "create_context_edit_plan",
     "create_editorial_plan",
     "preview_editorial_plan",
+    "preview_project_intake",
 ]);
 const DESTRUCTIVE_PREFIXES = ["delete_", "remove_", "ripple_delete", "close_"];
 const DESTRUCTIVE_TOOLS = new Set(["manage_project_context"]);

package/docs/supported-actions.md

@@ -8,11 +8,11 @@ descriptions, action enums, authority visibility, and counts stay aligned with t
 
 | Surface | Count | Availability |
 | --- | ---: | --- |
-| Registered core actions | 287 | CEP/local server catalog; host and authority checks still apply |
-| Default-profile core actions | 285 | Advertised with `inspect,edit,export,filesystem` |
+| Registered core actions | 288 | CEP/local server catalog; host and authority checks still apply |
+| Default-profile core actions | 286 | Advertised with `inspect,edit,export,filesystem` |
 | Restricted core actions | 2 | Require explicit `unsafe-script` authority |
 | Authenticated UXP additions | 50 | Advertised only while a compatible authenticated UXP panel is connected |
-| Default profile with UXP | 335 | 285 core plus 50 UXP tools |
+| Default profile with UXP | 336 | 286 core plus 50 UXP tools |
 
 ## How to read support
 
@@ -218,6 +218,7 @@ operation” when the tool has no enum-based mode.
 | `play_timeline` | Default profile | Single operation | Start playback of the active sequence timeline. Uses QE DOM. |
 | `preview_edit_plan` | Default profile | Single operation | Validate and preview a compound timeline edit without changing Premiere. Returns a confirmation token required by apply_edit_plan. |
 | `preview_editorial_plan` | Default profile | Single operation | Revalidate an exact server-issued editorial plan against the saved project-context revisions and return an opaque confirmation token. This tool is read-only and cannot apply the plan. |
+| `preview_project_intake` | Default profile | Single operation | Inspect a bounded Premiere project against an explicit facility intake template and return a path-redacted report plus a non-mutating organization proposal. It never changes Premiere or persists the template. |
 | `razor_all_tracks` | Default profile | `track_type`: `video`, `audio`, `both` | Razor (split) all clips at the playhead position across all tracks, or at a specific time. |
 | `redo` | Default profile | Single operation | Redo the last undone action in Premiere Pro. |
 | `refresh_media` | Default profile | Single operation | Refresh a project item to pick up changes to the source file |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "premiere-pro-mcp",
-  "version": "1.12.2",
-  "description": "MCP server for Adobe Premiere Pro with 287 core AI video editing tools and a capability-aware UXP bridge for supported Premiere workflows.",
+  "version": "1.13.0",
+  "description": "MCP server for Adobe Premiere Pro with 288 core AI video editing tools and a capability-aware UXP bridge for supported Premiere workflows.",
   "main": "dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",

package/uxp-plugin/manifest.json

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