Orgbench

Version 0.1.5 · Synced 2026-10-28 · Source README.md · Download .md

Orgbench

Overview

Orgbench is an IntelliJ IDEA Tool Window for comparing Salesforce metadata between two endpoints — a locally authenticated sf alias or a local git repository on either side, in every combination — and selectively deploying the differences into the target. Objects and custom fields, custom metadata types and platform events, Apex classes and triggers, Lightning Web Components and Aura bundles, Visualforce pages, page layouts and flows are available out of the box; fourteen further categories of metadata types are switched on in the settings, for 191 items in fifteen groups in all. One of those fourteen categories, Revenue Cloud, carries both metadata types and configuration records and is switched off by default. Salesforce authentication stays in the installed Salesforce CLI: the plugin never implements OAuth, never asks for credentials and never persists a token. Reading an org — listings, SOQL queries, object describes and REST sub-resources — runs the CLI too by default; with Read orgs through set to Salesforce API (faster) it goes straight to the Salesforce REST, Tooling and Metadata APIs with the access token the CLI itself reveals for an alias, held in memory only, while retrieves, deployments, logins, the Bulk API writes of Prepare orgs and the list of aliases still run the CLI.

The first screen lets you pick a metadata type and build a session manifest of non-namespaced components across one or more types before comparing — except the seven types that carry a permission (CustomField, CustomObject, PlatformEvent, ApexClass, ApexPage, CustomTab, RecordType), where a namespaced component is listed too, as a Permissions only row. "Non-namespaced" is decided by the component's own name: a managed-package object is listed, because the unmanaged components inside it are yours, while its own definition is never compared. Objects & Custom Fields is one item: selecting a custom object there compares both the object definition and that object's custom fields, so you never have to pick the same object twice, while a standard object contributes its custom fields plus its own Permissions only row, which carries its CRUD and no metadata, and that same selection also produces Permissions only rows for its standard fields, which carry field-level security and no metadata. A deployment sends everything you selected as one package, so a source-only object can be created in the target in the same deployment as its fields. An explicit permission transfer mode can also synchronize field-level security, object CRUD, Apex class access and Visualforce page access after a component is deployed successfully, or without redeploying metadata when the component already matches the target. Until you pick a type, the screen shows Selected components — every component selected so far, of every type, in one table — and it comes back to that view after Import Session….

The plugin bundles a native core, sf-core-server, and talks to it over a JSON-RPC 2.0 stdio protocol. Bundled native core binaries ship for macOS arm64, macOS x64, Windows x64 and Linux x64. A VS Code extension provides a second thin client of the same sf-core-server core, packaged as a platform-specific VSIX; see vscode/README.md.

Requirements

  • IntelliJ IDEA 2024.2+.
  • A Java 17-compatible IDE runtime for the plugin UI. The bundled native core (sf-core-server) needs no JRE.
  • A supported native platform: macOS arm64, macOS x64, Windows x64, or Linux x64. The Linux binary is statically linked against musl, so it needs no particular system libc version.
  • Salesforce CLI (sf) installed. The plugin checks the IDE process PATH and the standard macOS/Linux user and system install locations. On Windows it looks for sf.exe, sf.cmd, sf.bat and sf in PATH and in %LOCALAPPDATA%\sf\client\bin.
  • Claude Code (claude), only for Describe differences with Claude Code, which is off by default: installed and signed in once by running claude in a terminal. The plugin looks for it in the IDE process PATH and in its standard install locations every time the item is chosen; nothing else in the plugin needs it.
  • git 2.25 or later — only for deploying into a local git repository (Orgbench passes the file paths to git on standard input); comparing against a git repository does not need it.
  • Two authenticated aliases that resolve to different Salesforce org IDs, when both sides of the comparison are orgs. A side that is a local git repository needs no alias.
  • Source and target users with the API, metadata, and data permissions needed by the selected operations.
  • Target objects must either already exist or be explicitly selected as CustomObject rows in the same deployment; a source-only custom object is created in the target before its fields deploy.

Check the CLI and aliases in a terminal before opening the Tool Window:

sf version --json
sf org list --json

If aliases are not configured yet, authenticate each disposable or approved org explicitly:

sf org login web --alias source-dev
sf org login web --alias target-qa

The terminal is no longer the only way in: the + button next to the Source and Target dropdowns runs the same sf org login web for you. Enter a name for the new alias, choose Production, Sandbox or My Domain, and the plugin opens your browser for the sign-in. The alias is created by the Salesforce CLI exactly as the commands above would create it, and the plugin then selects it on the side you asked from. The plugin never sees your credentials, never sets a default org, and never overwrites an existing alias — a name that is already in use is refused with the reason before the browser opens.

Restart IntelliJ IDEA after changing PATH; a GUI-launched IDE can inherit a different environment from an existing terminal. On macOS the plugin also detects ~/.local/share/sf/client/bin/sf, /opt/homebrew/bin/sf, and /usr/local/bin/sf, so a standard Salesforce CLI installation does not depend on the GUI application's reduced PATH.

Install from Disk

  1. Obtain orgbench-0.1.5.zip, or build it as described below. Do not unpack the ZIP.
  2. In IntelliJ IDEA, open Settings/Preferences | Plugins.
  3. Open the gear menu, choose Install Plugin from Disk, and select the ZIP.
  4. Restart the IDE if prompted.
  5. Open View | Tool Windows | Orgbench.

The Tool Window checks sf version --json when it loads. It then discovers local aliases. A missing or incompatible CLI is reported with remediation text; choose Restart after correcting the prerequisite. An empty alias list is reported with remediation text too; add an alias with the + button next to the Source dropdown, or authenticate one in a terminal and choose Reload Orgs.

Workflow

The Select Source and Target screen: source and target aliases chosen and the Metadata Type dropdown open

  1. Select Source. The Source and Target dropdowns support type-to-search: with a dropdown focused, type a case-insensitive alias prefix to jump to matching aliases. The icon left of + in an org row opens the selected alias in your browser, on its Lightning home page, through the Salesforce CLI's own sf org open and your CLI session; it is unavailable until an alias is selected and while the screen is busy, a git row has none, and a refusal of the CLI (for example an expired authorization) is shown on the selection screen with its cause. In a container (SF_CONTAINER_MODE or SFDX_CONTAINER_MODE set) the CLI does not open a browser, so the plugin refuses with that reason and the action — open the org from a terminal on your computer; on a headless host (for example over Remote-SSH) the browser of the machine where the core runs opens — or none does, and the plugin cannot see which. Pick a Metadata Type from its dropdown (Objects & Custom Fields, Custom Metadata Types, Platform Events, Apex Classes, Apex Triggers, Lightning Web Components, Aura Components, Visualforce Pages, Page Layouts, or Flows); the plugin loads customizable components of that type into a filterable table, excluding namespaced ones by their own name — except the seven subject types (CustomField, CustomObject, PlatformEvent, ApexClass, ApexPage, CustomTab, RecordType), whose namespaced components are listed too, as a Permissions only row; managed-package objects are listed under Objects & Custom Fields so that their unmanaged fields can be selected, and so that their own CRUD can be selected too, as a Permissions only row that carries no document. The dropdown is grouped by metadata category and lists only the categories you enabled in the settings; out of the box only the Core category is enabled, so the list is exactly the one above. Enabling a further category adds its types under their own group heading; fourteen categories are available beyond Core — Objects & Fields, UI & Navigation, Code, Automation, Security & Sharing, Integration & Auth, Service Cloud, Experience Cloud, Analytics, Sales Cloud, Email & Templates, Localization, Mobile and Revenue Cloud — and together they carry 148 further metadata types plus, for Revenue Cloud, 33 configuration records rather than metadata types (fourteen of the 148 are Revenue Cloud's own pricing metadata types and its two record rows — Product Bundles and Constraint Models — listed under that same category), so with every category enabled the dropdown offers 191 items in fifteen groups. Data Cloud and Tableau Next objects are not offered in any category: Data Cloud moves its own configuration between orgs with Data Kits and Data Cloud packages, which Orgbench does not replace. The Revenue Cloud category is switched off out of the box. Typing in the dropdown searches those labels by substring in the IntelliJ plugin unconditionally, in the VS Code extension only when the combined list exceeds 11 types. If the type you were looking at belongs to a category you just switched off, the screen moves to the first type still on the list rather than showing rows of a type the dropdown no longer offers. Custom Metadata Types (__mdt) and Platform Events (__e) are object-form definitions listed by their name suffix; their fields are compared and deployed under Objects & Custom Fields like any other object's fields. Type a case-insensitive fragment in the API Name or Label filter cell to match that column anywhere in the value, not just its start (leading and trailing * are optional and ignored); check individual rows, use the header checkbox in the Select column for select-all-visible, or use Select All and Clear, which apply only to the currently visible, filtered components. The selections you make across metadata types accumulate into one session manifest — switching Metadata Type does not discard a prior type's selection, and a summary line reports how many components are selected per type. The dropdown's first item, Selected components, is where the screen starts: it loads nothing from the org and lists every component selected so far, of every type, in one table with the columns API Name, Label and Metadata Type, every row checked and the column filters working as on a type's own table. Unchecking a row removes it from the selection at once, and unchecking the header checkbox removes every visible row; to bring a row back, pick its type and check it again (a type that is not in the dropdown, such as ExpressionSetDefinition from an imported session, can only be brought back by importing the session again, and a type of a disabled category needs that category enabled in the metadata categories setting first). Label is filled only for a type the plugin has listed from the source in this session — after Reload Orgs, or for a type you never opened, it stays empty — while API Name is always there. With nothing selected the table is empty and the screen says Pick a Metadata Type to list its components. A Page Layout, Lightning Page, Report Type or Context Definition carries a second checkbox, Elements, right of the selection checkbox — in a type's own table and in Selected components alike, where the rows of other types leave its cell empty: ticked, that document is compared element by element, unticked, as a whole document (see Comparison Rules). Ticking a component sets its Elements to the Element-level merge setting of that moment, and so do the selection column's header checkbox and Select All for the rows they tick — rows already ticked keep theirs; unticking the component clears it, and ticking the component again takes the setting anew. Its cell stays disabled until the component is ticked (Tick the component first.), and its header checkbox acts on the visible ticked rows. To change it after Compare, press Back: the selection screen keeps every document's Elements checkbox.
  2. Select Target. Different aliases are still rejected if they resolve to the same underlying org ID. The last source and target orgs you picked are remembered on this machine — only their aliases, in the same private data directory as the license key, never a token, an instance URL or a repository path — and are selected again the next time the selection screen opens; an alias the CLI no longer lists is simply left unselected, and a repository endpoint is not remembered.
  3. Select at least one component and choose Compare. Source and target metadata are retrieved into separate temporary projects. A comparison and the deployment that follows it run at the lower of the two orgs' own Metadata API versions as the Salesforce CLI reports them (65.0 when neither is known), so a type that only a newer release offers — Procedure Plan Definition, for one — is fetched and deployed at a version that has it; when a retrieve still brings nothing back, the error names the reason Salesforce gave.
  4. Review the Select, Type, Component, Change, and Diff columns. A field row whose target object is missing becomes selectable once the table also carries that object's deployable CustomObject Add row; you still have to select that row too, or the deployment is rejected before it starts. Custom CustomObject rows are deployable; a standard object contributes a Permissions only row instead, carrying its CRUD and no metadata document, because only custom objects can be deployed as metadata.
  5. Each column filters independently from a filter row beneath the headers. Type a case-insensitive fragment in the Type or Component cell to match that column anywhere in the value, not just its start (leading and trailing * are optional and ignored). Use the Change multi-select to pick any subset of Add, Update, and No change; by default only Add and Update are checked; if the comparison has no Add and no Update row at all, every value is checked, No change included. The Select column's filter cell is a tri-state checkbox: checked shows only selected rows, unchecked shows only unselected rows, and the greyed (indeterminate) default applies no selection filter. The separate header checkbox still selects or clears only visible, eligible rows and becomes indeterminate for a partial visible selection. A row you selected stays selected when a filter hides it, and the deploy buttons count it: beside them the screen says <N> selected row(s) hidden by the table filters. with a Show them link that clears every filter of the table and shows every kind of change, No change included (when the selection also carries records, that text comes after the one about records).
  6. Use Back to close the comparison and return with the current Source, Target, per-type component catalog, and session manifest preserved. Alternatively, select fields, choose Do not transfer permissions, Additive permissions, or All permissions from Permissions transfer, and choose Next. In Do not transfer permissions no confirmation dialog follows: pressing a deploy mode button starts that deployment at once. In Additive permissions or All permissions, Next instead opens a container-selection screen listing every eligible container with its Existing/New presence column, filterable through the Presence column's multi-select (both shown by default); Select All/Clear apply only to the currently visible, filtered containers. That screen — and the Next button leading to it — appears only when at least one checked row carries a permission subject (a field, an object, an Apex class, a Visualforce page, a tab or a record type); otherwise the review screen shows the deploy mode buttons directly, because there is nothing to transfer. Deselect any selectable container to exclude it, or Back to return to the review. Choosing Next there is the confirmation step for the permission path.
  7. During comparison or deployment, the screen shows the live progress line and Cancel, which stops new work and asks the active CLI process to terminate when possible. Cancelling does not cancel the Salesforce deployment job itself: it stops the local CLI process, and a deployment already submitted to Salesforce may still run to completion in the org minutes later, even though the plugin reports the operation Failed … cancelled. One place keeps working after Cancel: the activation of a pricing procedure version or of a constraint model version that follows a deployment. When Cancel lands there, the plugin still makes up to three more calls so that the target is not left without a working version — a re-read of the target's versions, the rollback activation of the previous version and, if that is refused, a second re-read — and each of them is bounded by the channel's own timeout, not by Cancel, so the screen can stay busy for a few minutes before the results appear. The decision tables the deployment switched off for itself get the same treatment once the package has landed: the call that activates each of them again, and the one re-read after a refused call, are not stopped by Cancel. A Cancel earlier, while the package is still travelling, cannot tell whether Salesforce will complete the deployment; when the selection goes as two packages and Cancel comes while the second one travels (or its call fails before Salesforce answers), the first package has already landed and stays: the rows of the second package are Failed with The second package stopped before Salesforce answered (<reason>); … and the results screen appears, not the error screen (in Best Effort, when the first package put no row into the target, nothing had landed yet and Cancel during the second package is a hard cancel, as before any landing); when it carried decision tables rewritten to Inactive, the cancellation text names them (If Salesforce still completes this deployment, these decision tables arrive inactive: <tables> — activate them in Setup → Decision Tables.). The waits after the package landed — for decision tables to finish activating and for the target's Context Service to show the new context attributes — show their own progress line, which stays on the stage of the wait for as long as it lasts, between its reads too, and Cancel during them ends on the results screen instead of discarding it. When a wait had to pause, the line returns once, when it is over, to what it showed before the wait (Deploying the package after the package, the records line against production when the records came first); a wait that is answered by its first read changes nothing. If you close the IDE or the VS Code window while a deployment is running, after its decision tables were rewritten to Inactive, Salesforce may still complete the deployment and the tables then stay inactive with no result row to say so — check them in Setup → Decision Tables.
  8. Read the component and permission result tables. In the permission result table, the Status column filter hides Skipped rows by default; check Skipped in that column's filter to reveal them alongside Updated, Failed, and Not Attempted. Show Details and Copy expose only sanitized diagnostics. Their text lists every component row but only the permission rows that change the target or were meant to — Updated, Failed and Not Attempted; the number of Skipped permission rows is named in one closing line, and the rows themselves stay in the permission table under the Skipped filter. Next to the Succeeded, Failed and Not Attempted counters the screen shows Not activated: N when N rows landed Succeeded but stayed inactive: a pricing procedure or constraint model version whose activation failed, was skipped or was cancelled, or a decision table the deployment could not activate again; the row's message says what the target shows. New Comparison returns to the alias selection and keeps the marks of the next screens as if the session had been exported here and imported on the first screen: the checked rows, the permission containers, the Apex tests and the deploy mode hint (after a Re-Deploy, those of that re-deploy — the rows that went out in it — not of the original deployment). The permission transfer mode is a setting and is not carried; document edits and the Target health check choice are not carried either. Clear All Selections drops the carried marks, and so do choosing a different source or target org and an org of the pair missing from the org list on load (marks from an imported file are not dropped by those two). To send again the rows the target did not accept, check them in either table and press Re-Deploy (see Deployment Behavior).

The Deployment Results screen: every component Succeeded and the permission rows Updated

Git Source and Target

Each side of a comparison is chosen independently: a Salesforce org or a local git repository (an absolute path plus a branch). All four combinations work — org to org, org to git, git to org, git to git. A repository side is read through the SFDX layout declared by its sfdx-project.json: every packageDirectories entry is scanned in file order, and on a duplicate component the first entry wins. A source repository without sfdx-project.json is rejected; a target repository may be empty or not yet an SFDX project, in which case the plugin creates a minimal sfdx-project.json and a force-app/main/default/ skeleton inside the same commit. A target repository that already has an sfdx-project.json the plugin cannot parse is a hard error instead — the skeleton never overwrites an existing manifest.

If the folder picked as the target failed inspection — most commonly because it is not a git repository yet, but the same button also appears if the inspection failed for another reason (a timeout) — an Initialize a Git repository here button appears next to it, as long as the location is still safe to run git init in and git itself runs on this machine. Which paths are eligible is decided entirely by the core: a plain filesystem check for a .git entry anywhere in the folder or its parents and for a bare repository at any of those levels, plus a git version probe whose exit code alone says whether git works here — never a parse of an error message; a machine where git cannot run at all fails that probe and is offered no button, because pressing it could only fail. When the probe or the toolchain markers are why the inspection itself failed, the refusal says so: Git is not usable on this machine. Run 'git version' in a terminal and install or repair git until it prints a version., followed by the same sanitized reason the toolchain itself gave, instead of claiming that the folder is not a repository — the same message and the same action for both a broken toolchain and git being entirely absent from the machine (no executable at all), because both are fixed by the user the same way. Only the target side is ever offered the button — an empty repository has nothing to compare from as a source — and the button is hidden again while an inspection or initialization request for that side is in flight. Confirming shows the full path and creates nothing beyond the .git directory itself: no commit, no branch checkout, no push, and the initial branch name is left to your own init.defaultBranch rather than a name the plugin picks.

Branch reading follows one rule: the current branch is read from the working tree, so uncommitted edits are part of the comparison, while any other branch is read from the git objects. The branch dropdown lists local and remote branches; picking origin/foo as a target means "create or use the local foo from it". When a whole type is read from a repository (the * member), a branch file that cannot be copied into the comparison does not fail it: a file whose path is not safe, a file git cannot hand over, and a file whose name is the same as another one's on this file system are each left out with a warning of their own — The branch file <path> was left out of the comparison: <reason> followed by the action, rename, fix or remove the file in the branch and compare again. The reason of a name clash reads another file of the branch has the same name on this file system (the two names differ only in letter case or in Unicode normalization). A skipped path keeps its place: when the same path lies in a later package directory too, that second copy is not compared in its stead. A git timeout or a git that does not work is still a failure of the comparison. Warnings about the files of a branch begin with the side they come from, Source branch: or Target branch: .

Deploying to a repository writes the selected components into the layout, stages exactly those paths and makes one commit — the deploy ends in a local commit, pushing is up to you, and the plugin never checks out a branch in your repository: a branch other than the current one is written through a temporary git worktree that is removed afterwards, and when the target branch is the current one only the written paths are committed, so unrelated modified files stay out. The "+" button next to the branch dropdown names a new branch, and that branch is created only by the deploy commit — cancelling the session leaves nothing behind. After that commit the same session treats the branch as an existing one: a second deploy of the session (Re-Deploy from the results screen, or Back and Deploy again) puts the next commit on it, one commit per deploy, and builds its merges from the branch as it now stands, first commit included; the (new) mark shows only in the branch dropdown of the selection screen. A name given with "+" that already belongs to a branch of the repository this session did not create (made in a terminal, or by an earlier session) is refused with The branch '<name>' already exists in the repository, so Orgbench does not create it again. Pick it from the branch list instead of naming it with +, then deploy again., and a write into the working tree is refused when the repository's checked-out branch is no longer the target branch (The branch '<name>' is no longer the checked-out branch of the repository (HEAD was switched after it was picked), so Orgbench does not write into the working tree. Check it out again or pick the branch again, then retry.). Deploying a bundle (LWC/Aura) to a repository target can delete files: a file left over inside that bundle's directory from a previous version is removed, and the deletion is part of the same commit. A component that already lies in one of the repository's package directories is rewritten where it lies — the first packageDirectories entry, in file order, that holds its bundle directory or one of its files, every folder on the way being a real directory (a package directory that is a symlink is not entered) — and all files of one component go to that one directory; a component the repository does not have yet is written into the default package directory. Nothing is written until every path of the deployment has been checked: a deployment is refused, with nothing written, when a symlink or a regular file lies where a folder of the destination should be (The folder <path> of the target branch is a symbolic link or a file, not a real folder, so nothing is written through it. Replace it with a real folder in the branch, or deploy into another branch, then deploy again.), or when the branch ignores a destination through a .gitignore rule or an exclude file of the repository (The target branch ignores <paths> (a .gitignore rule or an exclude file of the repository), so the commit could not include them. Remove that rule, or deploy into another branch, then deploy again.; a tracked file under an ignored folder is deployed as usual). A third refusal comes before the first write too: a git older than 2.25 does not accept file paths on standard input (Deploying into a git repository needs git 2.25 or later: Orgbench passes the file paths to git on standard input. Update git, then deploy again.), while any other refusal of git's check — a locked .git/index.lock, a repository it cannot write to — arrives as git's own answer. The paths are then staged with git add -f. A refusal of a deployment into a repository, of reading a repository or of the repository side of a comparison is headed by its own text when the plugin wrote it — the three refusals above, a bare repository, an invalid new branch name, nothing to commit, a git older than 2.25, a git that cannot run, a git command that did not finish in time (The git command did not finish in time. Try again; if it keeps timing out, set the log level to Detailed and look in the session log for the git command that was waiting.), a branch of the source that was deleted or renamed after it was picked (The branch '<name>' is no longer in the repository (deleted or renamed after it was picked). Pick the branch again, then retry.), a repository whose folder belongs to another user account of this computer (Git refuses to work in this repository because its folder belongs to another user account of this computer. If you trust it, run git config --global --add safe.directory with the full path of the repository's folder (git names that folder in its answer), then try again., git's own answer under Show Details) — so the heading of the error screen already says what to change; when the text is an answer of git or of the file system (a locked .git/index.lock, a permission error), the heading is The git repository operation did not complete. What git or the file system answered is under Details; fix what it names, then try again. and the answer is under Show Details. If every selected row is dropped while the package is prepared, the heading is The package was not deployed: <first reason>, followed by (N more reasons are listed under Details.) when there are more, and Show Details lists every reason once.

With a repository target there are no deploy modes and no Apex test screen: the write is atomic by construction and the Salesforce CLI is not involved at all. Dependency auto-selection needs the Tooling API and is therefore unavailable for a repository source, with one exception: when the source is an org (whether the target is an org or a repository), a Page Layout's own dependency on its custom fields is read straight from the layout XML and auto-selected without the Tooling API. When the source itself is a repository, this offline layout auto-select is unavailable too, exactly like every other dependency. Two selection rules need no Tooling API at all and therefore work with a repository source as well: a field row whose object is missing from the target auto-selects that object's Add row, and checking that object's Add row auto-checks the object's own field rows. The review screen still warns about every other Tooling-sourced dependency it cannot compute for a repository source. Permission transfer does work with repository sides — Profile and Permission Set documents are read from and written to profiles/ and permissionsets/ files in the same commit, and a Profile file is only ever updated, never created.

GitHub endpoints are not yet supported: the entry is visible but disabled, and the core rejects it.

Session Export and Import

Export Session writes what the current session has selected so far to a JSON scenario file (default name session.json). The button itself is a save icon on all five screens, not a text label — its tooltip and accessible name are Export Session…. The button is on five screens — object selection, component review, Apex test selection, permission container selection, and results — and each of them writes what is known by then: the two endpoints and the comparison manifest, with the Elements checkbox of each of its documents, from the selection screen (including the checkboxes of the type you are looking at right now, which are committed into the manifest first); the checked comparison rows and the permission transfer mode from the review screen; the checked Apex test classes from the test screen; the checked permission containers from the container screen; and the deploy mode that actually ran from the results screen. The whole file is still serialized and written by the plugin core, exactly like the manifest export — but unlike the manifest export, the core does not already hold what goes into it: the client shows a save dialog and hands the core the path and the live marks of the screen the button was pressed on, because that is the only place those marks live before you deploy or finish the wizard.

The file is meant to be replayed later against a disposable org, so it deliberately does not snapshot the comparison itself. There are no difference rows, no statuses and no attribute values in it — a replay has to run the comparison again, because a snapshot of the differences would go stale the moment either end changes and would then be wrong while still looking green. Document edits are not in it either: an edit lives inside its own comparison session and dies with it.

Nothing secret reaches the file by construction — only metadata names, org aliases, branch names and modes. A git end is written as the repository directory's last path segment plus the branch name, never as an absolute path, exactly as everywhere else in the plugin.

Two conventions matter when you read the file. An absent field and an empty one mean different things: a missing apexTests means the test screen was never reached, while "apexTests": [] means it was reached and no test was checked — a real deployment without Apex tests. And deployMode travels with deployModeIsFinal: on the test and container screens the mode is still provisional and the wizard's final button can overwrite it, so only the results screen marks it final. The file carries its own version, independent of the plugin's protocol version.

Export is refused, with a reason naming what to wait for, on every screen that has nothing to write: while orgs or components are loading, while the comparison is running, while a deployment is running, and on the error screen. An empty comparison manifest on the selection screen is refused too, because a scenario without a single component is not a scenario.

Import Session…, its tooltip and accessible name identical in both clients, is a button on the object selection screen that reads a scenario file back in — a file of any version from 1 to 5, either one written by Export Session or handed to you by someone else. The format moved from version 1 to version 2 to add a field naming the session's own current screen; a version-1 file, which has no such field, is still read without any refusal. Version 5 added elementDocuments, the documents compared element by element: a version-5 file brings back the Elements checkbox of each document it restores exactly as it was written, while an older file gives every page layout, Lightning page, report type and context definition it restores the Element-level merge setting of the moment of import. Importing does not start anything and does not go anywhere: you still walk the wizard yourself — pick Compare, move on to the review screen, and so on — and each screen shows its marks already checked when you reach it, the same way the Apex test screen already checks a preselected candidate. What is restored, screen by screen: both endpoints and the comparison manifest, applied immediately on import; the checked comparison rows and the permission transfer mode, applied when the review screen is built; the checked Apex test classes, applied when the test screen is built; the checked permission containers, applied when the container screen is built. Every one of these marks is applied once per set — the same rule as preselected test candidates — so a mark you uncheck afterward does not come back just because the screen is rebuilt for another reason. Import does not run the comparison, does not move you past the selection screen, and does not touch either org beyond the ordinary source-org component listings the file's own manifest is checked against — it is not a replay, only a set of marks waiting for you to reach their screens yourself. The marks are dropped by Clear All Selections, by Restart on the error screen, or by importing another file (a New Comparison from the results screen replaces them with the marks it carries); choosing the source or target org by hand afterwards, or an org missing from the org list, does not drop them.

The deploy mode in the file cannot be pre-selected, because there is nothing to select it into: the review screen has no deploy-mode switch, only three buttons — Validate only, Deploy, Best-effort deployment — and each one starts a deployment the moment you click it, so none of them may be the default (pressing Enter must never start a deployment). The recorded mode is therefore only shown as a text hint next to the deploy summary (Previously chosen: …) and never pressed on your behalf. The permission transfer mode is different: it is a real setting, and importing restores it for real.

A name the file carries but the plugin no longer accepts — the component was renamed, deleted, or changed type since the file was written — does not fail the import. Each unaccepted name is listed, one line per name, on the screen where it turned out to be unaccepted: a manifest member missing from the source org's listing is reported on the selection screen, in the same import summary banner manifest import already uses; a comparison row the file selected but the current comparison does not have is reported on the review screen, because that can only be known once the comparison has actually run; an unmatched permission container is reported on the container screen the same way. Permission containers the file names are applied only on the container screen, so when that screen will not open for the rows the file selects — none of them carries a permission subject, or the file's permission transfer mode is Do not transfer permissions — the review screen says so in the same list, with what to change to use them, instead of dropping them silently.

The endpoints work the same way. An alias the file names but your local CLI does not have is not an error either — that endpoint is simply left as it was, and the alias joins the same list of unaccepted names. A git target is never restored at all, and that is not a gap: the file, like every other output of the plugin, carries only the git repository directory's last path segment and the branch name, never the absolute path, so there is nothing to point the plugin back at — a git endpoint stays whatever it was before the import, with a warning saying so. The org-to-org pair restores in full; a git endpoint you still choose by hand.

The comparison manifest is only applied when there is a source org to check its names against — either the source the file itself just restored, or one you had already selected before importing. When neither is available, the manifest is left exactly as it was, with a warning explaining why, rather than filling the selection screen with names nobody has verified against a real org; import the file again once you have picked a source.

Import is refused, the same exhaustive way export is, from every screen except object selection — there is nothing sensible to import into mid-comparison or mid-deployment.

Session Export and Session Import are both among the advanced features reserved for the paid tier described under Licensing below — together they absorbed the manifest export/import gate, since the pair is a superset of what that older feature did. Like every other feature in early access, nothing is gated today, so both buttons write or read the same file for everyone regardless of license state; a refused license verdict returns the same plain-text reason as any other refusal on this screen.

Comparison Rules

Components match by metadata type and API name (fields additionally by their SObject Type). The plugin shows:

  • Add when the source field is absent from an existing target object;
  • Update when a matching field differs in a supported attribute;
  • No change when supported attributes are equal;
  • no row for target-only fields, because the plugin never deletes fields.

The Change multi-select controls which source rows are visible: check any subset of Add, Update, and No change. It defaults to Add and Update checked, so No change rows are hidden until you check that value — unless the comparison has no Add and no Update row at all, in which case all three are checked (the scenario is transferring permissions to unchanged objects or classes). A No change row is never a metadata deployment candidate. It becomes selectable only in Additive permissions or All permissions mode, and returning to Do not transfer permissions immediately deselects all such rows.

Updates compare these attributes in deterministic order: type, formula, default value, lookup or master-detail target, length, precision, scale, and label. A short diff is rendered source-to-target, for example Length: 40 -> 80; Label: Old -> New. A custom field is, besides, compared as a whole document: the eight attributes stay the short description of what changed, and a difference anywhere else in the field's document — its description, help text, picklist values, the required flag — reports as Definition changed, next to the attribute differences when there are both. XML formatting alone (indentation and other whitespace between elements, a byte-order mark, the XML declaration, the final line break) is never a difference. The history tracking toggles of a field, trackHistory and trackFeedHistory, are not compared, because they never travel (see Safety Boundaries): fields whose documents differ only there are No change. A Permissions only field of a standard or managed-package object never shows a difference.

Namespaced metadata is ignored. The rule is about the component's own name: a namespaced field such as namespace__Field__c never has its DEFINITION compared or deployed on any object, and neither does a namespaced list view, layout, Apex class or tab; a namespaced component of exactly the seven types that carry a permission — CustomField, CustomObject, PlatformEvent, ApexClass, ApexPage, CustomTab and RecordType — does get a comparison row, because a row is how its permission is selected; a namespaced list view or layout still gets none, because neither type carries a permission of its own. For a Layout, that name check is a label-prefix test with no other signal on a git target: a layout that truly belongs to a package but whose label carries no namespace prefix is treated as unmanaged there, indistinguishably from a layout an admin actually added. A managed-package object is a different question. namespace__Object__c already exists in every org that installed the package, exactly as Account exists in every org, so the plugin treats it like a standard object: its definition is never compared and never deployed — it gets a Permissions only row, which carries the object's CRUD and no metadata — while the unmanaged components an admin added inside it — custom fields, list views, validation rules, layouts and the rest — are compared and deployed like any other object's. That is why managed-package objects appear in the object list: they are the only gate through which their unmanaged fields can be selected. The MVP does not try to detect a packaging org in which that namespace is under development. Standard fields are not copied either — their definitions never travel; they do get Permissions only rows, which carry field-level security and nothing else.

When an object is absent from the target, its source fields are displayed as Add with Target object is missing. Those field rows become selectable once the table also carries the object's deployable CustomObject Add row; otherwise they stay disabled. Selecting the field still requires selecting that object row too: if you select such a field without selecting its object row, the deployment is rejected before it starts with Missing target object 'X__c': select its object row or deselect its fields.

CustomObject metadata is compared like any other type — Add, Update, and No change rows are computed the same way. Only a custom object (__c) gets a metadata definition row: a standard object selected in Objects & Custom Fields contributes its custom fields plus its own Account-style row, but that row carries Permissions only — its CRUD, never a metadata document — mirroring the rule that standard fields are never copied as metadata either.

Custom Metadata Types and Platform Events are the same object form on the Metadata API (a CustomObject component), so they behave exactly like custom objects: a source-only __mdt or __e object can be created in the target in the same deployment as its fields. A Custom Metadata Types row that is not a __mdt object is disabled with Only custom metadata types can be deployed., and a Platform Events row that is not a __e object with Only platform events can be deployed. Custom Metadata records (Type.Record) are covered too, as Custom Metadata Records under Objects & Fields: unlike the object definitions above, a record is compared as the whole document rather than attribute by attribute.

Apex Classes and Apex Triggers are a code type: each component is its source body (.cls/.trigger) plus an XML sidecar carrying apiVersion and status. Comparison covers the body text and the sidecar attributes together, so an Update row can come from a body change, a sidecar change, or both. The row diff view keeps the two documents apart: the body and the sidecar each get their own window, and which of them a double-click opens is described in Row Difference View below. Visualforce Pages have the same shape: the .page body plus a .page-meta.xml sidecar carrying apiVersion and label.

Lightning Web Components and Aura Components are bundles: one component is a whole directory (lwc/<Name>/, aura/<Name>/), so they are compared by composition rather than by attributes. An Update row means the set of files or the content of at least one file differs, summarized as N file(s) added, M removed, K changed (terms that are zero are omitted); the row diff view shows the whole bundle as one concatenated document, each file preceded by a === <relative path> === separator line. Deploying a bundle replaces that bundle in the target completely: a file that exists only in the target's version of the same bundle is gone after the deployment, because the Metadata API treats a bundle as one indivisible component. The plugin still never deletes a target component: a bundle that exists only in the target produces no row and is never touched.

Page Layouts, Lightning Pages, Report Types and Context Definitions are compared in one of two modes, chosen for each document by its Elements checkbox on the selection screen; a newly ticked document starts with the Element-level merge setting. A document the comparison itself adds to the manifest — a context definition a selected pricing procedure reads, for one — is compared as a whole document whatever the setting, and one table can carry the element rows of one document next to the whole-document row of another. A Context Definition follows rules of its own in both modes — what its comparison leaves out, its element rows and the forecast of Salesforce's own sync — described with its other rules below. In the default mode, Compare and deploy whole documents, one row is one whole document: the two documents are compared in full — line endings and XML formatting (indentation and other whitespace between elements, a byte-order mark, the XML declaration, the final line break) are not differences — and any other difference reports as Definition changed. Deploying such a row replaces the target document with the source document, so a section, a field, a related list, a Lightning page component or a report type column that exists only in the target's copy of the same document is gone after the deployment; that is the Metadata API's own semantics, and the row that carries it is visible in the table before you deploy. In the second mode, Select elements to merge, these documents are decomposed: one row is not a whole document but a single element — a field of a section or a related list of a page layout, a field or a component of a Lightning page, a column of a report type. In that mode a document that exists in the target produces rows only for the elements that differ, and matching elements produce no row at all; an element that exists only in the target never produces a row and is never removed. Position is never a difference: the plugin transfers a new element into the position its source neighbours dictate, but it never re-orders elements that already exist in the target. A selected related-list Update row replaces the whole related list with the source version — its columns, sort field, sort order and buttons are all overwritten, so anything present only in the target's copy of the same related list is gone after the deployment; everything else in the layout — the layout's own buttons, quick actions, the highlights panel and the mini layout — is preserved by construction: existing lines are never rewritten. A report type column is keyed by its table and field (Duplicate_Report::field:DuplicateRecordSet/Has_Master__c, with #2 on the second occurrence of the same pair in one report type): a column whose Checked by default or Display name differs is an Update row that replaces that one column, a new column goes after its nearest source neighbour in the same section, and a section the target does not have is created with the columns you selected; the section a column sits in is not a difference. A report type column on an object the target report type does not join is visible but cannot be selected: the row names the object and the action — deploy the whole report type. The document-level properties are not compared or transferred in the element mode — a layout's own buttons, quick actions and mini layout, a Lightning page's label, template, description and parent page, and a report type's label, description, category, deployment status, base object and joins — untick the document's Elements checkbox for them. Both modes agree on the rest: a document that is missing from the target produces one Add row for the whole document, a document that exists only in the target produces no row and is never touched, and Layouts of standard objects are compared and deployed. The row difference view shows the whole document of both orgs, the same document for every row of that document. In the element mode a document whose own name contains :: is excluded from the comparison with a visible warning, because the plugin uses :: to address elements. A layout whose metadata cannot be parsed is not softly excluded: reading that layout's metadata fails the operation outright, the same way an unreadable metadata file fails any other type.

A Lightning page — every FlexiPage, record, app, home, utility bar and mail app pages alike — is decomposed in the element mode into the fields of Dynamic Forms and the components on it. A page is a tree: a tab set, a tab, a field section or a column holds its content in facets, and the plugin gives a row only to the topmost element the target page does not have — a new field section is one Add row that carries its columns and fields with it (Account_Record_Page::component:flexipage_fieldSection3, and the row says how many fields and components travel inside it), while a field gets a row of its own only inside a section the target page already has (Account_Record_Page::field:Record.Phone, with #2 on the second occurrence of the same field on one page). Components are matched by their identifier together with their component name anywhere on the page, the columns of a section or a grid by their identifier together with their component name first and then by position among the columns not yet paired, and fields by their field name — first inside the matching section or column of the target page, then among the target page's fields of that name and of the same kind (Dynamic Forms or highlights panel) that are not yet paired, so a field that sits in another section is not a difference, and the #2 only numbers the occurrence on the source page; a new element whose fields the target page already shows says so in its note (Adds record_flexipage:dynamicHighlights with 1 field and 0 components inside it. 1 of its fields is already on the target page: Record.Name.); a matched field whose behavior or visibility rule differs and a matched component whose properties or visibility rule differ are Update rows, and a selected Update row replaces that element's own properties and visibility rule while the content of its facets stays as the target has it. A new element goes after its nearest source neighbour in the same region or facet, the facets of a new component are added to the target page with it, and a facet name or an identifier the target page already uses gets a numeric suffix. An element of a region the target page's template does not have is visible but cannot be selected: the row names the region and the action — deploy the whole page. Dynamic Forms here means a field section (flexipage:fieldSection), a component that has a field section inside it, or a field inside a field section; the fields of other components, such as the highlights panel, are not Dynamic Forms. When the target page shows its fields with the Record Detail component (force:detailPanel) and the source page has no Record Detail of its own, every Add row that carries Dynamic Forms says that it removes the target page's Record Detail — in its differences, as Removes from target, and in its note — because a page with both would show the fields twice; deploying such a row puts the selected sections in place of Record Detail, fields of sections you do not select will not be on the page, and the result of each such row ends with Dynamic Forms replaced the Record Detail component force_detailPanel of the target page. (in Validate only the row reads Deploying this would make Dynamic Forms replace the Record Detail component force_detailPanel of the target page., because nothing was changed; a Quick Deploy result carries the note in the deploy form). The opposite direction is refused: a Record Detail row for a target page that already uses Dynamic Forms is visible but cannot be selected (a page uses Dynamic Forms when it has a field section with fields); a row for a component with a Record Detail inside it is refused the same way.

In the element mode a Lightning page also gets rows for its assignments — where the page is activated: the object default (Account_Record_Page::assignment:object/Account/View/Large, kept in the actionOverrides of the page's object), the app default (Account_Record_Page::assignment:app/standard__LightningSales/Account/View/Large) and the app assignment by profile (Account_Record_Page::assignment:profiles/standard__LightningSales/Account/View/Large/Account.Fleet_Sales — one row per app, action, object, form factor and record type, with the profiles inside it; - stands for an empty segment). The plugin reads them from the documents of the apps and of the pages' objects on both sides, so a comparison with Lightning pages in the element mode also retrieves every app and the pages' objects; those documents give no rows of their own. The apps are retrieved by name: the plugin first lists the custom applications of each org side and retrieves them by * together with the listed names, because a wildcard retrieve alone does not return them all (measured on 13.10.2026 against a sandbox that lists 59 applications: * returned 45, the names returned all 59). An application that a side's listing named but the retrieve did not return gets one warning per side that names the applications (ten at most, then (and N more)) — The application <X> was listed by <alias> but not returned by the retrieve; its Lightning page assignments are not compared. — applications of managed packages (ns__App) are retrieved by name as well, because * returns none of them (a name that cannot be put into a retrieve manifest gets one warning, The application name <name> of <alias> cannot be put into a retrieve manifest; the applications of <alias> are retrieved by wildcard, which leaves out packaged applications and may leave out others.), and an assignment whose application belongs to a managed package is an unselectable row — The application <app> belongs to a managed package, and the plugin never deploys a managed package's application. Assign this page in the target's Lightning App Builder. — while no whole-document row of a packaged application appears; and when a side's listing cannot be read, that side is retrieved by * alone and the warning says so (The applications of <alias> could not be listed: <detail>; they are retrieved by wildcard, which may leave some of them out of the Lightning page assignments.). Each assignment is looked up in the target by its key: no assignment there — the assignment is new (Add); the same page — no difference; another page or Default — the row is an Update that replaces the target's assignment on that key and names it in its differences. An assignment of the target that the source does not have is never touched. Deploying merges the selected assignments into a fresh copy of the target's app or object document — one component per document, however many rows and pages go into it — and nothing else of that document changes; an object's assignments go as one component together with the selected children of the same object (list views, record types and the like), which Salesforce accepts or rejects together — one rejected child fails the whole object component; a selected row of the whole app or object carries its assignments itself (Carried by the whole-document row of …). If the target's app or object changed on an assignment's key between Compare and the deployment, that document is not sent and its rows fail with … changed since Compare (…); compare again. A standard app (standard__…) and a standard object receive exactly that and are never deployed as whole documents. When the target's app repeats the same assignment byte for byte, Salesforce rejects every change to that app, so the deployment sends each repeat once and the row says so before the deployment and in the result of an accepted row; repeats with different pages make every row into that app unselectable with the reason. A repeat in the target's object document is handled the same way. Against an org target, a profile the target does not have is left out of its row and named in the row's note — when the table also carries the whole-document row of that application, the note says that row leaves them out as well: Left out: profile(s) <…> are not in the target; the whole-document row of <App> leaves them out too. — and a row with no profile left cannot be selected; the whole-document row of a custom application sent to an org target is likewise sent without the assignments of profiles the target does not have (a profile that a selected Profile Add row of the same deployment creates is kept) — Salesforce rejects the whole application over one of them (invalid cross reference id) — and its result names them: Left out: page assignment(s) for profile(s) <names> — the target has no such profile, and Salesforce rejects the whole application over one (invalid cross reference id). (ten names at most, then and N more; an application row you edited in the difference view is sent as you wrote it, and its result names the profiles the target does not have (Sent as edited: the document assigns pages to profile(s) <names> the target does not have, and Salesforce rejects the whole application over one (invalid cross reference id).; a listing that fails changes nothing for such a row); when the target's profiles cannot be listed, the application rows with such assignments fail in Best Effort and the whole operation is refused in Validate only and All or nothing); the same row is also sent with each assignment that the source document repeats identically once, because Salesforce rejects the whole application over a repeat (You specified one or more duplicate ProfileActionOverride values.) — the row says so before the deploy (The source's application <App> repeats <N> page assignment(s) (profile(s) <names>); the deploy sends each of them once.) and its result says Sent once: <N> page assignment(s) the source's application repeats (profile(s) <names>) — Salesforce rejects the whole application over a repeat (duplicate ProfileActionOverride values).; an application row you edited is sent as you wrote it and says Sent as edited: the document repeats <N> page assignment(s) (profile(s) <names>), and Salesforce rejects the whole application over a repeat (duplicate ProfileActionOverride values).; a git target receives the document as it is, and an assignment repeated with different content is not judged; against an org target, a record type the target does not have makes the row unselectable unless the record type's Add row is in the table, which is then checked with it (a git target is not asked, so neither check runs); a page the target does not have is checked with its assignments; an app or an object the target does not return makes the row unselectable, and the row names the action: for a custom app, add it to the comparison (Custom Applications) and deploy it whole first; for a custom object, deploy the object, then compare again; for a standard app or object, enable its feature in the target, then compare again. When Salesforce answers invalid cross reference id for an app, it does not say which reference; the row names the profiles and record types its assignments carry.

Types outside the core set — every type of the fourteen additional metadata categories (Revenue Cloud carries twelve pricing metadata types, two record-row items and 33 configuration records: the pricing types are compared as a whole document like any other type here, the 33 configuration records are not compared as records, and product bundles and constraint models are compared as whole documents of their own two items and transferred, a bundle as records and a model as its definition shell plus records) — are compared as the whole document, not attribute by attribute: one row is one component, and the row difference view shows both documents in full. Their component name is the fullName the Salesforce CLI reports, so a tab of a custom object is listed as Invoice__c and a quick action as Account.New_Note. Namespaced components of these types are excluded like every other namespaced component, decided by the child's own name rather than by its object: Account.acme__View is excluded and acme__Packaged__c.My_View is not, and a name that is a custom object's own API name is not mistaken for a namespace prefix. Two of these types are the exception, because they carry a permission of their own: a namespaced Custom Tab or Record Type is still listed, as a Permissions only row whose tab visibility (or record-type visibility) you can select even though its definition never travels. Types that Salesforce stores inside an object's folder — list views, record types, validation rules, field sets, compact layouts, business processes, indexes, sharing reasons and web links — are listed under a composite Object.Name key such as Account.AllAccounts or Invoice__c.My_View, and their file lives in that object's folder. Children of a standard object are compared and deployed like any other child, because a list view or a validation rule is the admin's own configuration rather than the object definition; the standard object's own definition is still never deployed. A managed-package object is treated the same way, for the same reason and with the same limit on its own definition. Selecting a child of a custom object that is missing from the target auto-checks that object's definition Add row as a visible dependency — you see it in the table before the deployment and you can uncheck it. The object's own custom-field rows are auto-checked right alongside it, because a list view's columns or a validation rule's formula name those fields, and the target rejects the child if the object is created without them; each field row can be unchecked on its own, just like the object row. Like the offline layout auto-select, this widening runs when the source is an org; with a repository source neither the object's row nor its field rows are added automatically — select them yourself. Types that Salesforce stores many-to-a-file — assignment rules, auto-response rules, escalation rules, the three kinds of sharing rule and custom labels — are listed one row per rule or label, not one row per file: a rule is keyed Object.Name such as Lead.Web_Leads, and a custom label by its own name, because a single CustomLabels file holds every label in the org. For these types the packaging rule above does not apply: gating is decided by the whole container name — the object name for a rule, the label's own name for a custom label — rather than by comparing a child segment against its object. The three sharing-rule types share one physical file per object and are told apart by the element that carries them, so an owner rule and a criteria rule of the same object are two independent rows that deploy together into one file.

Some of those whole documents leave their service tags out of the comparison — tags that describe each org's own copy, its release, the version's number and start date, the table's last data sync: a Context Definition is compared without its root releaseVersion and without startDate and versionNumber of its version block, and a Decision Table without lastIncrementalSyncDate. A row whose documents differ only there is No change; the row difference view still shows those tags as a difference. A Decision Table parameter's fieldPath that equals its fieldName word for word does not count as a difference (Salesforce writes that duplicate into some tables and not into others), while a path through a relationship, such as ContractItemPriceId.StartDate, is. The row difference view still shows such a fieldPath as a difference, like the service tags. A Decision Table's root dtRowLevelOverrideType with the value None does not count as a difference (Salesforce writes it into some orgs and not into others); any other value is one. The row difference view still shows a None dtRowLevelOverrideType as a difference. An expression set version's LookUpId or DTId parameter, also inside the nested versions of an expression set definition (the Id of a decision table in its own org, which Salesforce resolves again by the table's API name and rewrites itself) does not count as a difference; a parameter with any other name does. The row difference view still shows it as a difference. The order of a Decision Table's repeated blocks, such as decisionTableParameters, is not a difference either: Salesforce returns them in a different order from different orgs, and the row difference view shows the target in the source's order, the target pane titled <alias> (in the source's order). A Context Definition is also compared without the order of its neighbouring blocks: Salesforce keeps its repeated blocks — nodes, attributes, mappings — in the order they were added and reorders them itself when it saves a version, so a deployment cannot carry their order to the target. A context whose documents differ only in that order, or in that order and its service tags, is No change; its row difference view shows the target in the source's order and says so in the title of the target pane, <alias> (in the source's order). The rule is the same for a git target: such a context is No change, so the file in the branch keeps its own order. That order carries no meaning for Salesforce either: a deployment from the branch is reordered by Salesforce itself when it saves the version.

In the element mode a Context Definition that exists in the target is decomposed too: one row is one element of the definition — a node, an attribute, a tag, a mapping, a node mapping, an attribute mapping, a hydration, a hydration context or a mapping intent — named by the path of its keys (CKSalesTransactionCtx::context:node=SalesTransactionItem/attribute=NetMargin__c); the Component column shows the row under a readable label instead — the definition, the kind of the element and the keys of its path (CKSalesTransactionCtx::Attribute SalesTransactionItem › NetMargin__c) — with the full path in the cell's tooltip, and the Component filter matches both; the session export and the selection keep the path. A new element whose parent the target has is one Add row that brings everything inside it (an attribute with its tags, an attribute mapping with its hydrations); an element whose own properties differ is one Update row; an element that exists only in the target produces no row and is never touched. Only a new element of your own can be selected, because a live run showed what Salesforce does with the rest. A deployment that changes an existing element of a context definition reports Succeeded while the target keeps its value, so an Update row is visible but cannot be selected: for an element of your own its reason names the action — deactivate the definition in the target, edit the element, activate it again — and for a standard element it says that Salesforce sets its properties when it syncs the definition with the standard one. A standard element (one that carries <inheritedFrom>) that the target does not have is visible but cannot be selected either: Salesforce brings standard elements into an extended definition when it syncs the definition with the standard one — in the live run they arrived together with a sync, and Salesforce describes Sync Now on the definition's Custom Definitions tab in the target for starting one. Against a git target there is no platform behind the branch, so a new element of either kind can be selected, while an Update row cannot and names the action: untick the definition's Elements checkbox and compare again to carry changed properties into the branch. Selecting an attribute mapping whose attribute is new auto-checks that attribute's row, visibly and removably; when that attribute's row cannot be selected, the mapping's row cannot be selected either and says why. The rows of one definition deploy as one component: the selected elements are inserted into a fresh copy of the target's definition, nothing in it is changed or removed, and a definition into which nothing could be inserted is not sent at all. A row whose element the target already has, or whose parent the target no longer has, fails and asks you to compare again (a parent left empty in the target's copy fails the row too, and that row says to untick the definition's Elements checkbox and compare again instead); in Best-effort, and against a git target in every mode, the other rows of that definition still travel, while in Validate only or All or nothing against an org target the whole deployment fails before any deploy call. Inside its parent a new element goes where the schema's order of child tags puts it — after the parent's last child of the same kind, when there is one; Salesforce itself moves new blocks to the top of their list when it saves the version, and that order is never a difference. In Best-effort against an org target the rows of one definition are retried together, as one document rebuilt by the same merge into the same copy of the target's definition from the source trimmed again; an element that the retry's trim removes entirely is not sent again. The definition's own properties — its label, description and version block among them — are not compared or transferred in the element mode; untick the definition's Elements checkbox for them. A definition whose element keys are empty or repeat under one parent is compared as one whole document even in the element mode, and its row says so (Compared as a whole document).

In both modes a Context Definition row against an org target shows, before you deploy, what Salesforce is expected to do to the target's definition when the source's definition is itself in sync with the standard definition of its release. A live run showed that a deployment into a definition that is behind the source's release — its inheritedFromVersion is lower — makes Salesforce sync it with the standard definition whatever the package carries: one deployment that sent a single tag added 114 standard elements, changed 4 properties of standard attributes and REMOVED 8 standard attribute mappings that the deployed document still carried. So when the target's definition is behind, the row's summary starts with Salesforce syncs the target's definition <X> → <Y> on deploy; standard elements: <a> added, <c> changed, <r> removed (<X> is the target's inheritedFromVersion, <Y> the source's), and its differences Salesforce sync, Sync adds, Sync changes and Sync removes list the elements; in the element mode the forecast is on every selectable row of that definition, because deploying any of them starts the sync. When the two definitions are on different releases the plugin cannot list the elements, and the row says only that Salesforce syncs the target's definition with its own release on deploy. The same goes for a definition that the plugin has to compare as one whole document because its elements cannot be told apart (a repeated key, two versions in one document): when the target is behind, the row says Salesforce syncs the target's definition <X> → <Y> on deploy; the elements are not listed because the definition is compared as a whole document and carries the same words in its Sync difference, instead of showing no forecast at all. The forecast blocks nothing and changes nothing in what is sent. The forecast assumes that the source's own definition is in sync with the standard definition of its release: Salesforce syncs the target with the standard definition of the TARGET org, not with the source document, so a source that itself lags behind makes the lists incomplete, and a target that is not behind the source but is behind its own org's standard gets no forecast although a sync will happen. In the whole-document mode the row also lists, under Not applied by Salesforce, the existing elements whose changes Salesforce will not apply, and its summary counts them; the row stays selectable, because the rest of the document lands. After the deployment a Succeeded row repeats the forecast in its message as an expectation — Salesforce was expected to sync the target's definition from <X> to <Y>; standard elements: … — because the plugin does not read the target again to confirm it. Validate only writes the same forecast as a prediction on its result row (Salesforce is expected to sync the target's definition from <X> to <Y> when this is deployed; standard elements: …), and Quick Deploy hands to its results the notes that the validation produced for the components it deploys, in the deploy form above. Hovering a row of the comparison table — in VS Code, the row's Details cell — shows every difference of that row with its full source and target values, for every metadata type — that is where the lists of a Context Definition row are read.

Product Bundles and Constraint Models are two more of those types, and they are unlike every other one: what they compare is not a file in the org but RECORDS. A Product Bundle row is one Product2 whose Type is Bundle, identified by its name, and the plugin synthesizes its document out of the bundle's own catalog — the classifications it is based on and their parent chain, its component groups, its related components, the child products those components name (one level, with a child that is itself a bundle marked as such and its own structure left out), the selling model options and the price book entries of the bundle and of each child. References inside that document are natural identities, never record ids: two sandboxes cloned from one org give the same bundle two different ids, and an id-keyed transfer would create a duplicate instead of an update. A Constraint Model row is one ExpressionSet whose usage type is Constraint, identified by its API name; its document carries the definition shell and each version shell exactly as the Metadata API returned them, the CML text of every version read through the REST subresource, and the model's own tags with their addressee resolved into the same natural identities. A tag whose addressee no longer resolves is not dropped — it stays in the document with its raw id, because an exclusion you cannot see is indistinguishable from one the plugin never found. Which fields of a record travel is the INTERSECTION of both orgs' describes — a field one org does not have is left out of both documents, and the document's own schema section names what was compared and what was left out, so the narrowing is visible in the diff rather than inferred. Both types are listed by SOQL and compared only between two orgs: with a repository on either end the plugin refuses the listing and the comparison with Product bundles and constraint models are compared between two orgs only. Two bundles of one name on one side, two component groups of one name inside one bundle, or two names that differ only in letter case make the row unselectable with an Ambiguous … reason naming the records; the document is still built, so you can see what the collision is about. Both rows are TRANSFERRED. A bundle row deploys its catalog as RECORDS, through the REST composite API, and only in Best-effort against an org target (against a production org, as phase 2 of Deploy instead — see Deploying to a production org below) — records have no dry run, the transfer runs as several calls with no transaction between them, and the plugin deletes nothing in the target, so "all or nothing" is not physically possible for them. A Constraint Model row travels under the same rule and in two halves. First its definition shell goes into the same Metadata API package as the button's other metadata, as one ExpressionSetDefinition member whose nested versions are planned against the target: the version the target already runs as active is left out of the package untouched, and every other version travels Inactive, the new ones included — so the package never changes which version is active, and the source's own status is never sent. Then, after the package, come its tags, CML and activation as REST calls: a tag is created only where the target does not already carry the same tag on the same record, the CML of a version is written only where it differs from the target's, and the version that is active in the source is activated in the target — the target's active version deactivated first, then the new one activated — but only when that version's CML landed or already matched: a version whose CML was refused is not activated, and the row says Activation skipped: <version> did not receive its constraint model; the target's active version was left as it is. When the new version cannot be activated after the old one was deactivated, the old one is activated again, and the row says so (<old version> was activated again). When a call of the activation answers with an error — a refusal, a timeout, a cancellation — the model's versions are read again from the target before anything else is sent, because such an answer does not tell whether the call landed: an activating call that did land counts as done, the previous version is activated again only when the target shows no version active or could not be read, otherwise the row names the version the target shows active (the target's versions, read again, show <version> active; when that is the new version after a refusal, the row begins <new version> is active in the target or Activated in the target instead of Activation failed), and it sends you to Setup only when the target, read again, has no active version or could not be read. A text whose conclusion comes from that second look is worded as what the look showed, in the past tense — when the target's versions were read again, <old version> was active., … when the target's versions were read again, no version of <model> was active — activate one in Setup. — because the activity can change between the read and the moment you see the row. When it is not known whether the old version was deactivated at all, the row says <old version> is active instead of was activated again. Nothing is deleted: not a tag only the target has, not a version, not a record. The row is Succeeded only when the target now carries the content the source carries that it could place: a tag whose addressee the target does not have is left out, counted and named in the row's Message (without addressee in the target) and never fails the row — the next transfer of the model, which the comparison then shows as Update, creates it once the addressee exists; a product a tag addresses is looked up by the same external key the bundle's own record is matched by first, then by its name, and the Message counts the ones found by key (addressees matched by <field>: N) and names each whose name in the target differs; a version without its CML, a tag the source itself could not resolve, an ambiguous addressee (ambiguous product <name> in the target (N records by <field>) when two target records carry the key) — each makes the row Failed, while an activation that did not happen leaves the row's status alone and is stated in its Message, which states counts and names, up to ten of each. The comparison names those tags before anything is deployed: the model row's Summary ends with Tags: … — how many tags would be left out without addressee in the target, how many address records that a bundle row of the same comparison creates (addressed to records that bundle row <name> creates — check it to deploy them together, or addressed to records that bundle rows <name>, <name> create — check those rows to deploy them together when several bundle rows do; checking those rows sends the records ahead of the model in the same deployment) and how many would make the row Failed (would fail the row); the first and the last group name up to three tags each. If the target could not be asked, the tail says so instead — Tags: addressees in the target were not checked: <reason>; compare again to check them — keeping the tags whose failure is known without the target; a model document that could not be read shows Tags not checked: the document could not be read. A model whose target copy differs inside the version the target runs as active does not transfer that difference at all: that version is left out of the package instead of being sent and refused (can't update … because it's active, measured live), and one refused definition takes the other models of the same package down with it — deactivate that version in Setup and deploy again. The comparison itself brings in every constraint model whose tags address a bundle being compared — its groups, components and child products included — as a row marked required by <bundle>; checking that bundle's own row then checks the model too, as added as dependency — every model the plugin can actually deploy that has an active version in the source; a model without one, a No change model and a blocked model stay unchecked, still visible in the table as required by <bundle>, and a model left out for its version says so in that same place (required by <bundle>; not auto-checked: no active version in the source) when the bundle is what brought the model into the comparison; a model you picked yourself on the selection screen stays unchecked without a note. The warning Product bundle … is tagged by constraint model …, which is not in this comparison. is left only for a model the plugin could not list, and when the dependency warnings run past fifty the last line says how many were not shown. You see the mode rule before the button, not after it: checking a bundle or a constraint model row removes the Validate and Deploy buttons and puts one sentence under the row, Records cannot roll back: Best Effort only. A production target has no Best Effort button at all, and there a checked record row keeps Validate and Deploy: Deploy transfers the records after the metadata, as described under Deploying to a production org below. Unchecking every record row brings the modes back. When another screen follows — Apex tests or permission containers — the review screen still shows Next, and the mode is chosen on the last screen, where the same two buttons are missing for the same reason. Against a non-production org the records travel BEFORE the Metadata API package of the same button, layer by layer — classifications by their parent chain, then products (the bundle and its child products together), then component groups by their parent chain, then components, then selling model options and price book entries — because the composite API does not resolve references between records of one call; against a production org they travel in the same layer order but AFTER the package (see Deploying to a production org). A record of the target is matched first by its external key, then by the natural identity above, and created only when neither matched; two matches are a refusal of that record, never a guess. A child product that already exists in the target as an ordinary Product2 under the same name — not itself a bundle — matches by that same identity and receives the document's fields as an update, even though the comparison table never showed that target record: the row you checked is the source's own bundle, and the table does not display the target side of a records row the way it does for a metadata row. The bundle itself is different: when the target has no bundle of that name but has a record the external key of the source's bundle record points at, or a record of that same name, the bundle's Add row says so instead of Missing in target. When that record is ALREADY a bundle (Type = 'Bundle') under another name, the row stays Add and deployable with a note, for example In ckrcatest as bundle Florida (matched by Legacy_Key__c); deploying updates it: renames it to Florida (OPIS+) (the rename part shown only when the target can update Name); deploy it as it is — the record is updated, and its groups, components, selling model options and price book entries that hang under the old name are matched rather than created again — or uncheck it. When that record is anything else — a plain product, or no Type at all — the row is UNSELECTABLE instead, because Product2.Type is createable but not updateable (describe of both measured orgs, 27.09.2026) and no deploy can ever turn it into a bundle: In ckrcatest as product Florida with no Type (matched by Legacy_Key__c); the target does not let Type change, so it cannot become a bundle. Clear its Legacy_Key__c or delete it in ckrcatest, then compare again. — the plugin neither clears the key nor deletes the record itself. Two records found either way make the row unselectable with Ambiguous product bundle identity: … — remove the extra record in the target and compare again. When the target already HAS a bundle of that name (an Update or No change row) and the external key of the source's record points at a DIFFERENT record there, the row is unselectable too, for the same reason: deploying by the key would update that other record instead of the bundle, and the bundle of the same name would stay untouched: The name matches bundle Florida in ckrcatest, but Legacy_Key__c matches product Widget with Type Base there; deploying would update that record, not the bundle. Clear its Legacy_Key__c or delete it in ckrcatest, then compare again. The same key finding the SAME record, or finding nothing, leaves the row alone. After the deploy of a record accepted this way, the row's Message names the rename: renamed: Product2 <old> → <new>. The plugin deletes a record in the target only from the Target health check screen. That screen opens when you start a deployment with a product bundle row checked (Best Effort against a non-production org, Deploy or Validate against a production org) and the plugin found something in the target that would make the transfer fail — before the Apex test and permission container screens, so nothing has been sent yet. It names five kinds of finding: a record of the target that the target itself will not save (its own copy points at a record that is gone, in a field the target does not let anyone change); a duplicate — two or more records of the target that one record of the deploy matches by identity or by key, so the plugin cannot tell which one to update; a Choice no longer matches — a record chosen on this screen earlier that the target no longer offers among the matches, for a record that is no longer a duplicate, described below; a relationship type, a selling model or a price book that the target does not have; and a Broken reference — a target record the transfer matched, whose field the plugin does not transfer points at a record the target does not have, or that the user the Salesforce CLI runs as cannot see (Product2.Division__c, for one): the finding says that the plugin does not carry that field (a record of an object the transfer itself creates is never repointed either, the transfer creates a missing one anew under a new Id) and that this deploy does not change that field. When Salesforce refuses the wider read that looks for these references (a URI length or relationship limit, for one), the deploy repeats the read once without them and the screen shows one line per object, Broken references in fields the transfer does not carry were not checked for <Object>: <reason>, with no record id; that deploy is not affected, and Check target may show those references unless it meets the same limit. Each finding says what is wrong and what the plugin would do about it, and every finding the plugin can fix carries a checkbox, checked when the report arrives; a finding with no automatic fix cannot be checked at all. A Record Id column next to Record shows the target record the finding is about: one id for a fixable finding, every id of a duplicate (each on its own line), and nothing for a finding with no record to open. Each id is a link of the form <base>/<id> into the target org, or plain text when the target's base URL is unknown. The screen offers Fix, Deploy without fixing, Re-check and Cancel. Fix deletes only the findings you checked and shows the screen again with a fresh check; it is offered only when there is something the plugin can fix, it is absent rather than disabled otherwise, and it is disabled while nothing is checked. Against a production org the button is called Fix during Deploy and does not delete at once: the screen says Fix during Deploy deletes nothing yet: pressing it continues to Deploy, where the marked findings are deleted after the metadata deployment succeeds and before the records are transferred. That deletion cannot be undone. in place of the line about immediate deletion, the wizard moves on, and the marked findings are deleted inside Deploy, by the same rules, only after the metadata deployment succeeded and before the records; when it does not succeed, nothing is deleted. That deletion cannot be undone, in a production org as in a sandbox. Validate against a production org runs the check only when the selection carries a product bundle (a selection without one goes straight on, because there is nothing for Validate to check); there too the button deletes nothing, and the screen says Fix during Deploy deletes nothing yet, and Validate deletes nothing either: the marked findings are deleted when you press Quick Deploy, after the validated metadata deployment succeeds and before the records are transferred. That deletion cannot be undone. When the validation offers no Quick Deploy (it failed, or it ran without tests), nothing is deleted and the results say so: use Deploy to fix the findings and transfer the records. On the Validate route the buttons that continue are named Validate and Validate without fixing. Deploy appears once the check finds nothing, in place of Deploy without fixing; Re-check reads the target again without deleting anything. A duplicate of the target opens a second table under the findings, Duplicates: choose the record this deploy updates, one row per record of each duplicate: Use, Record, Record Id, Created, Last modified, Referenced by — how many records of the six transferred objects point at that record; quotes, orders, assets and other objects that refer to a product are not counted — Matches source — how many fields of the bundle's document already hold the source's value there — and Note. Check Use on the record the deploy should update: checking another record of the same duplicate moves the choice, and checking the chosen one again clears it. The deploy then updates that record, and the bundle's records under it follow it: a group, a component, a selling model option or a price book entry that hangs under another record of the duplicate is neither matched nor changed, and a missing one is created under the chosen record; a record of this deploy that points at another record of the duplicate through a link the target lets change (a parent group, BasedOnId) is repointed to the chosen one, and its row in the results names it; the other records stay in the target untouched, and nothing is deleted; the bundle's row in Deployment results names the chosen record and how many other matching records stayed. When the object carries the plugin's own key field, the deploy writes the key into the chosen record and later compares match it alone; without one, or when the records matched by the key itself, the choice holds for this deploy only. A record can be offered without letting you choose it: its Use is disabled and its Note says why — a product whose Type differs from the source's, because Salesforce sets a product's Type only when it creates the product, or any record but the one that another record of this deploy points at through a reference Salesforce does not let the plugin change. When no record of a duplicate can be chosen, its Fix text says so and the deploy refuses the row. When the dates or the references could not be read, those columns say unknown; a product whose Type could not be read says so in its Note and is not blocked for it; the deploy stays available. After Re-check or Fix the screen shows the choice the new check applied: a choice stays while the duplicate still offers that record and the record can be chosen — a duplicate that appears only once another duplicate's record is chosen keeps its choice too — and a choice the duplicate no longer offers is dropped and named at the end of the duplicate's Problem: the record chosen earlier (<Id>) is no longer one of them, choose again, or … can no longer be chosen (see its note), choose again. The findings of the bundle's other records are judged with the choice the screen shows as chosen, exactly as the deploy will judge them; a choice the screen shows as unavailable is not applied to them. A choice the target no longer matches is never replaced by another record, whether it was made for an earlier deploy and is seen by a Re-Deploy, or made on this screen and found gone by a Re-check or a Fix. A record that is still a duplicate has the choice dropped and named in its Problem, as above; a record that is no longer a duplicate is shown before anything is sent, as a finding of its own, Choice no longer matches: the record chosen on the Target health check (<Id>) is no longer one of its matches in the target; compare again and choose anew, with no automatic fix. The screen opens for it even when the check finds nothing else, and the finding stays unresolved, so the button is Deploy without fixing: the deploy refuses that record with the same reason and does not update the record that still matches in its place. When the chosen record is the only match left, the choice holds and the deploy updates it. If the chosen record is gone or no longer matches when the deploy starts, or a choice made afterwards on the same screen leaves another record of this deploy pointing at a different record of the duplicate, that record is refused with the reason and no other record is updated in its place; the reason says to compare again and choose anew, because a Re-Deploy repeats the choice and a new comparison starts without one. Fix drops from the choice a record it deleted itself, so the deploy creates that record anew instead of refusing it as a stale choice. One case stays without a note: a choice that the check drops at an intermediate step, when the record is offered again once the check settles, is dropped without one. Deploy also replaces Deploy without fixing when every finding left is a duplicate with a chosen record. A duplicate in the source offers no choice. With Deploy without fixing and a duplicate of the target left without a choice, no record under any of its records changes: a record of the bundle that hangs under it and would be updated is refused with it — <record> was not updated: <duplicate> matches <n> records in the target; choose the record this deploy updates on the Target health check — and counted among the records that depend on the findings above; one that already matches the source stays as it is, and one to be created is refused: directly under the duplicate with <duplicate> was not created, deeper — where its own parent exists — with the text above and was not created. A record of the target that cannot be saved and hangs under a duplicate left without a choice gets no Fix (its text says the deploy could not create it anew and names the reason): deleting it would not bring it back. The same holds for any record under a duplicate, at any depth: a group nested in a duplicate group, a component in that group, and so on. For a record whose owner is a duplicate in the source while the target holds several records for that owner, the text names the other action: … matches <n> records in the target; fix <owner> first, then choose the record this deploy updates on the Target health check. After you change a choice, Fix first checks the target again with it and deletes nothing (the screen says so); press Fix once more if the finding is still fixable.

Check target on the selection screen reads every Revenue Cloud registry object in the target — all 33, whatever you selected — and lists the records whose reference field points at a record the target does not have, or at one the user the Salesforce CLI runs as cannot see. The button stands next to Prepare Orgs, shown by the same rule, and is available once a target org is picked; no source is needed. The check only reads the target: it writes nothing and deletes nothing. Its report opens the same Target health check screen, with a line naming the target and a summary Checked N objects; M not found in the target: <A>, <B>. — in the IntelliJ plugin the names stand on their own line under the summary, where a long list wraps. An object not found either belongs to a Revenue Cloud feature the target does not have licensed or turned on, or is not accessible to the user the Salesforce CLI runs as; the screen says so after the summary and asks you to turn the feature on (it may need a license) or give that user access to the object, then press Re-check. When nothing is found the screen still opens and says No broken references found. One finding stands for one object and field: how many records point at how many missing records, up to 20 record ids as links, and the SOQL query that lists them all. What it says the plugin will do depends on the field: a field a Product Bundle transfer carries and the target lets change is pointed anew by a transfer that carries those records, when its deploy matches them (by name or by the external key); a field the target does not let change leaves those records unsaveable — deploy the bundles they belong to and use that deploy's Fix for a component, a selling model option or a price book entry, or repair the others by hand; a field the plugin does not transfer stays yours to repair — restore the missing records, for example by refreshing the sandbox with that table, or clear the field when the target lets you (a required or read-only field is fixed or deleted by hand). An object the target does not have is named in the summary, and an object the check could not read is named with its reason. The screen offers Re-check and Back, which returns to the selection screen as you left it; there is no Fix and no Deploy on it — nothing was compared, and nothing is deleted from this screen. When the target's sign-in has expired, or its alias has no authorization, the check stops at the object where such a refusal arrives, usually the first: the selection screen names the target's alias and the action — sign in again with the + button next to the Source or Target dropdown, then press Check target again — and the Salesforce CLI's own sanitized diagnostic follows the sentence on the same line, after Details:.

What Fix actually does is narrow by construction: it deletes the records that this very screen called findings of the first kind AND you left checked, of three leaf objects only — ProductRelatedComponent, ProductSellingModelOption and PricebookEntry — by the record ids the core itself read out of the target during this check. The client neither sends an id nor can send one. A deleted record is created anew by the deploy that follows, under a new id; constraint model tags that addressed the old record are deleted by the platform together with it, and they come back only for the models that travel in the same run — the screen says how many such tags each record carries. Nothing else is ever deleted: not a record of another object, not a version, not a tag on its own, not a field, not a component. Records that exist only in the target are never deleted: not an extra group, not an extra component, not an extra price book entry. ProductRelationshipType, ProductSellingModel and Pricebook2 are looked up by name and never created: a missing one refuses every record that names it, and the bundle is still created, so the partial success is visible in the row's Message. Where the target has the plugin's own OrgbenchExternalId__c field, every created and every matched record is stamped with it in the same call, so a repeat transfer runs by key; where it does not, the row's message says keys not stamped. A row whose target org the plugin has not confirmed to be non-production is not deployable at all — records never reach an org the core has not confirmed to be non-production. A target the plugin has recognized as production accepts records too, but only through Deploy and only after the metadata of the same deployment: there the records are step 2 of a phased Deploy, which starts only when the metadata deployment succeeded (see Deploying to a production org). A target whose class the plugin could not determine still refuses records.

Permission Sets and Permission Set Groups are two of those types, added to the Security & Sharing category. A Permission Set row is the whole .permissionset-meta.xml document, so deploying it moves everything that document carries — object and field permissions, class and page access, tab and record-type settings, and also the user permissions, the license and the application visibilities that a permission transfer never touches. That is a deliberate widening: the permission transfer merges six kinds of permission into a container, while a Permission Set row replaces the container itself. In Best-effort against an org target, and only there, the plugin treats that document by the Permission Set repair mode setting (OFF — the document travels as is and the target's rejection is that row's honest failure; TRIM_AND_RETRY, the default — trims that document before sending it, by two rules, and retries; TARGET_CONFIRMED — sends it as is first and retries only what the target named). The first: a userPermissions entry is removed when the source org's own describe of PermissionSet knows that permission and the target org's describe does not — a name neither org describes is left exactly as it is, because «we do not know it» is not «the target does not have it». The second covers the eleven kinds of reference a permission set carries — field and object permissions, class and page access, tab settings, record type visibility, application visibility, custom permission, flow access, custom metadata type and custom setting access: a block is removed when the target org does not know what it points at, or is kept when this same deployment creates it — a field, an object, a class or any other component travelling as its own row of the same package counts as known to the target, because the Metadata API resolves a reference inside the package it is deploying. The target is asked about itself, one question per kind the document actually carries, so a Best Effort deploy carrying a Permission Set asks the target up to seven metadata listings plus the standard-tab query — up to eight questions — plus its object schema before the package is built; a packaged application, custom permission or flow is never removed, for the reason the Profile paragraph below gives; fields are read through the Tooling API, which lists every field of the object, so a field the CLI user has no field-level security on still counts as known to the target. What was left out is named in the row's Message column, on a succeeded row as much as on a failed one, and the message states counts and names only: the plugin knows a name was not among the ones the target reports, not why. If the target still rejects the row, the plugin reads three forms: Unknown user permission: <name>, a missing reference by its tag and name (In field: apexClass - no ApexClass named <Name> found), and a permission that depends on another one (the dependent permission is removed; the ones it depends on are never added); only that row is sent again without what the target named — at most three more times in TRIM_AND_RETRY, at most four more times in TARGET_CONFIRMED — and its message says so. The repair mode is a snapshot taken when you press Compare: switching it changes nothing until the next Compare. In Validate only and All or nothing none of this happens: the document travels exactly as it is and the target's rejection is that one component's honest failure. The trim is skipped entirely with a repository on either side, where no describe can be asked at all; a repository source against an org target still gets the retry, because it needs only the target's own words and the row's own document. A row whose document you edited by hand is never trimmed and never retried. A Permission Set Group row is its own document too, and what it carries is a list of the permission sets the group contains, plain and muting alike. Namespaced permission sets and groups are not listed and never deployed, exactly like every other namespaced component, so an org whose groups mostly belong to installed packages shows only the unmanaged ones — a source org with twenty-one groups can legitimately list six.

Profiles are the third of those types in the same category, and a Profile row is the whole .profile-meta.xml document. Its name is the fullName the org itself lists, spaces and %-encoding included (Limited Access, Standard%3AUser), and the file it deploys is profiles/{fullName}.profile-meta.xml. Deploying a Profile row is a merge, not a replacement: the target keeps every block the document does not mention, and access is removed only where the source document says so explicitly — a false you can see in the diff before you deploy. What the row shows is exactly what each org handed over for the session's own manifest, and that can differ between orgs: with only Profile selected, one org returns the whole document while another returns its user permissions alone and adds the other blocks only for components that are in the same manifest. The plugin neither widens the manifest nor completes the document — it shows the two versions it was given.

An Add row of a Profile — a profile the target does not have — is deployable only when the source document carries <custom>true</custom>: such a profile is created in the target. A standard profile is never created; its Add row stays in the table, unselectable, and says so. Through the permission transfer screen no Profile is ever created, exactly as before.

Flows are always compared as a whole document: one row is one whole flow, with no mode to choose. Four header attributes are shown as a short diff — label, status, API version and process type — and any other difference in the document is reported as Definition changed. Version numbers are never compared, because the flow document does not carry one: the Metadata API decides which version it hands over, so the active version of a flow is compared, and when a flow has no active version its latest version is compared instead. An Update row can therefore mean that a different version is active in each org rather than that somebody edited the flow. The <status> value is transferred verbatim, so deploying a flow whose source status is Active activates it in the target; that status is visible in the row before you deploy — unless the row's document has been edited, in which case the row is marked Edited and it is the edited document's status, not the one shown in the row, that deploys — and Validate only is available as a dry run. Deploying a flow creates a new version in the target and never deletes or deactivates an existing version. A flow that exists only in the target produces no row and is never touched. This comparison has a known limitation for a git source compared against an org target: the plugin ignores line endings and XML formatting (indentation and other whitespace between elements, a byte-order mark, the XML declaration, the final line break), so what still reports as Definition changed between the repository's copy of a flow and the org's own serialization is what the comparison really sees — the order of elements and the values — such as a manual edit or an element the org writes in another order, and deploying does not clear it, because the target org re-serializes the deployed document on its own terms; every redeploy from that repository copy then adds another version to the target. The other three endpoint pairs are unaffected: org to org passes through the same Metadata API retrieval on both sides, so their serializations match by construction; org to git and git to git write exactly the retrieved or merged bytes, so the compared bytes are exactly the deployed bytes.

Dependency Auto-Selection

When you check a row in the comparison table, the plugin also checks every component that row depends on and that is missing from the target. The dependency data comes from the Salesforce Tooling API object MetadataComponentDependency, queried on the source org only; that object is a Salesforce Beta feature, so the plugin treats it as best effort.

The cascade also runs the other way for a new object: checking a new object's Add row also checks every custom-field row of that object, while checking a single field still checks only that field's object and not its sibling fields. Auto-checked rows are marked added as dependency together with the row that pulled them in, and you can uncheck any of them — the auto-selection is a suggestion, never a lock. Unchecking a row also unchecks the rows that were only there because of it; a row you checked yourself is never unchecked automatically. Dependencies are followed recursively, so checking one field can bring in its object and the Apex class they reference. They are read only for the components your selection needs: what you selected and what those components name, directly or through one another; an object the target does not have is followed whole, every field of it, when a lookup field points to it, an object child you selected belongs to it, or a context definition, a decision table, a dataset link or a custom metadata record reads it; a page layout or another reference that names one of its fields follows that field and the object's definition only. A retrieve brings all custom fields of an object at once, but a field that arrived that way and that nothing names is not followed further — a page layout of an object the target already has follows the fields on the layout, not every field of its object. With a repository target (org to git) the target's list of objects is read from the branch before the first round, so an object the branch already has is not followed whole; only when the branch cannot be read is every custom object followed as one the target does not have. The table, the auto-checks and the blocked rows are the same as before; the dependency warnings no longer name components that did not reach the table, and never name the definition of an object the target already has — in a target org or in a target branch that could be read.

A Constraint Model checks nothing but itself (decision of 21.09.2026): a tag whose addressee the target lacks is left out of the transfer and named in the row's message rather than failing it, so a model does not need the whole catalog. Checking a bundle also checks the models that tag it — every deployable model that tags it, by the bundle itself, a group, a component or a component's child product (the same rule that marks the row required by <bundle>), as removable added as dependency rows, and that has an active version in the source; a model without one stays unchecked, and its row says so when the bundle is what brought it into the comparison (required by <bundle>; not auto-checked: no active version in the source) — a model you picked yourself on the selection screen and that sits next to a bundle that tags it stays unchecked and says the same without required by (for an Update row, Definition changed; not auto-checked: no active version in the source) — as does a No change or blocked model, each showing its own reason, and the walk stops there: one checkbox reaches the bundle and its active models, never another bundle through a model — a bundle that CONTAINS bundles still checks them (below). A checked bundle also brings every model that tags it into the comparison in the first place, as a row marked required by <bundle>, and only a model the plugin could not list is still named in the dependency warnings.

A Product Bundle brings the bundles it CONTAINS with it: a child product that is itself a bundle is marked as such in the document, and checking the parent auto-checks that child bundle's own row, on both Add and Update — the parent only configures when the child's structure is already in the target. A child bundle with no row in this comparison is named in the dependency warnings instead; nothing is added to the manifest. Nesting that loops back (A contains B, B contains A) is safe: the transfer processes every checked row together, layer by layer, and needs no order between rows.

Only rows the target is missing (Add rows) are ever auto-checked: an Update or No change dependency already exists in the target and needs no transfer. A dependency the plugin cannot transfer — a standard component, a namespaced component, a managed-package object's own definition, or any component type outside the eleven the dependency graph covers (CustomLabel, RecordType, WorkflowRule, and the like) — is simply not auto-checked and never appears in the table. The one exception is a Flow dependency whose metadata name came from the Tooling API as its display name instead of its API name: it could not be matched automatically, so the row reports it, and you should make sure it exists in the target org or select it manually. Page Layouts are one of the eleven the dependency graph covers, but the Tooling dependency graph carries no layout references, so this feature never pulls a layout in as another component's dependency; a layout element's own dependency on a custom field is instead auto-selected offline, without the Tooling API, as described above. That offline auto-select also covers a whole-layout Add row: when the layout itself is missing from the target the comparison shows one row for the whole document, and that row carries the dependencies of every element it contains. A related list element is covered too: when the list is named {child object}.{lookup field}, the lookup field itself (if it is a custom __c field), every column of the list written as a plain custom field API name, and the sort field are auto-selected on the child object. A column written as a UI name (CONTRACT.NAME, OWNER_NAME) or as a person-account field (__pc) is left alone, and a standard related list — a name without a dot — has no dependencies at all. A report type column follows the same offline rule: a column on the report type's base object whose field is a plain custom field API name (Region__c of an Account report type) auto-selects that field, and a whole report type row carries the dependencies of every column it contains; the field's own row joins the comparison by itself, because a report type widens the session manifest with its base object's fields when the source is an org — with a repository source select the base object under Objects & Custom Fields — and a column reached through a join (Account.Gallons__r) is not followed, because the related object is not known without a describe. A Lightning page element follows the same offline rule: a field Record.Region__c of the page's object and a {!Record.Region__c} reference in an element's visibility rule auto-select that custom field, a component without a namespace prefix (creditCheckStatus) auto-selects its Lightning web component or Aura bundle row, a new component's row carries the dependencies of everything inside it, and a whole page row those of every element on the page. A page widens the session manifest with its object's fields the same way and under the same limit; a page without an object (an app, home or utility bar page) has no field dependencies, and when the source is an org, a custom component's bundle joins the comparison by itself: the plugin lists the source's Lightning web components and Aura bundles once for the comparison (only when a page names a custom component) and adds the one that exists, so its row is there for the checkmark to land. A name that neither list has stays a candidate that lands only if its row is in the comparison already, and a listing that cannot be read leaves the comparison as it was and says so (The source org's LightningComponentBundle components could not be listed: <detail>; custom components that Lightning pages use are not added to the comparison — select them to compare them.) — select the bundle under Lightning Web Components or Aura Components then; with a repository source nothing is added and you select it yourself. A Context Definition is one of several types where the Add-only rule above does not hold: its offline auto-select (the same principle as the layout one, without the Tooling API) reaches the custom fields its document names in a hydration mapping and the custom objects it maps a context node to, on both Add and Update rows, because a field the target already has but that differs still has to travel for the hydration to read the right value. When the plugin cannot deploy such a field at all — its object does not exist in the target org, and that object is a standard one, so no cascade can create it — the row is not left out silently: it stays in the table, unselectable, showing its own reason and the name of the context definition that referenced it. The second is a custom field that uses a global picklist: when the field's own source document names a global value set in <valueSet><valueSetName>, that Global Value Set row is auto-checked on both Add and Update, because the field's document carries none of the picklist's values itself — deploying the field without the set leaves you the target's values, or, when the target has no such set at all, the target's own refusal (The global picklist cannot be resolved). Mind what an auto-checked Update set does: a global value set is shared by every field that uses it, so deploying that row replaces the set's values for all of those fields in the target, not only for the field you checked — the checkmark is visible in the table and can be removed like any other. Like the other offline cascades this one widens the session manifest too, so the set gets its own comparison row without you having to pick the Global Value Sets type yourself, and — again like the others — only when the source is an org. A namespaced set is never followed, a No change set is never checked, and the cascade runs one way only: checking a global value set never checks the fields that use it. Four more offline cascades joined them on 2026-09-08, all of them Revenue Cloud configuration. A Decision Table auto-checks the custom fields its own document reads and the custom object it reads them from, on both Add and Update: the field of each parameter is the parameter's own fieldName on that parameter's own domainObject, or on the table's sourceObject when the parameter names no object of its own, plus a source criteria field written without a relationship path. A target that lacks the field rejects the table itself (Field 'Department__c' for object 'ProductDisqualification' used in Decision Table does not exists, measured live), and one package carrying the field and the table together is accepted, so nothing about the one-deployment rule changes. Exactly like a Context Definition, a referenced field the plugin cannot deploy at all — a custom field of an object the target org does not have, where that object is standard — stays in the table, unselectable, showing its own reason and the name of the decision table that referenced it. A pricing procedure — an Expression Set Definition or an Expression Set Definition Version, the two documents that carry its steps — auto-checks the decision tables its lookup steps name: the step parameter whose own name is LookUpApiName or DTName and whose type is Literal. The neighbouring LookUpId/DTId parameter is the SOURCE org's record id and is never read, because the target resolves the table by name and writes its own id; a procedure version deployed into an org that has no such table is rejected outright (Lookup API name: Gis_Based_Adjustment_Entries, but LookUpId is null, measured live). Since 2026-09-09 that cascade follows the delta rule instead: a table the target already has but that differs IS auto-checked, because a Decision Table document carries the table's DEFINITION — its source object, its parameters and its criteria — and not its rows, which are records of the source object that a metadata deployment never touches. The same procedure also auto-checks the Context Definition its own document names in contextDefinitions under the root, on both Add and Update, because the context defines the procedure's inputs. Since 2026-09-21 that cascade has a second direction of its own: a pricing procedure version auto-checks the Expression Set Definition it belongs to, on Add — the target refuses a version whose parent it does not have (We couldn't find the parent record for the version …, measured live on 2026-09-21) — and, against an org target only, on Update when the definition the target already has differs from the source's outside its versions (the row is then a removable dependency of the version and travels as a shell, so the target keeps its own versions); a definition the target already has with the same own properties needs nothing from this deployment. The definition's name is read from the version's own document (expressionSetDefinition), not from the version's file name, which is a flat API name with no separator in it. The definition type is no longer a dropdown item at all: the entry named Expression Set Definitions lists the VERSIONS, because that is what a pricing procedure travels as, and the definition itself arrives as this cascade's visible, removable checkmark. On the selection screen the versions of each definition come one after another, the latest version on top, with two more columns before API Name: Version (the version number the source org reports or the version's own document carries) and Status (Active for the version the source runs, Inactive, Draft…); the Status column filters by a choice of the statuses the list carries (all checked by default, (no status) for a version without one), not by text; when the source org does not answer the query for its versions, the list comes as before, without the two columns. Like every offline cascade it widens the session manifest only when the source is an org, a namespaced definition is never followed, and a definition row that a Constraint Model of the same name already deploys is never checked — that row carries its own block reason instead. A Context Definition now auto-checks other context definitions too: the ones its contextNodeMappings map a node to and the ones its contextDefinitionReferences name, on both Add and Update; a reference to itself, to a standard __stdctx context and to a namespaced one is never followed. A Pricing Recipe auto-checks the pricing procedure it runs (defaultPricingProcedureDeveloperName, the procedure's DEFINITION rather than one of its versions) on both Add and Update, and every decision table its pricingRecipeTableMapping blocks name that the target does not have yet (Add only: a mapping needs the table to exist, and a cascade must not switch off a changed table you did not pick). A pricing procedure version auto-checks the Pricing Recipe row whose source document maps a decision table the version reads while the target's copy of that recipe does not (an Update recipe only, against an org target only: a recipe the target does not have gets no checkmark from a version — the target judges the version by a recipe the plugin does not know — and a target copy that cannot be read builds no edge; you can still check an Add recipe row yourself), and against an org source the comparison lists the source's Pricing Recipes whenever it lists a procedure version. Like every offline cascade, the edges of these four — the procedure's context edge, a context definition's own cross-references, the pricing recipe's edges and the dataset link's edges below — are followed for either kind of source, while the manifest widening that gives a referenced row a place in the table at all runs only when the source is an org. A Decision Table Dataset Link auto-checks the decision table it is attached to, on both Add and Update, and the custom object it reads its rows from — that one on Add only, since the link needs the object to exist and an Update of its definition gives the link nothing. When that object is missing from the target, the link and a lookup field alike also auto-check every new custom-field row of that object, exactly as checking a new object's own row does: the object arrives in the table together with its fields, and each of those checkmarks can be removed on its own row. An object the target already has never brings its fields along — the target already knows them. A lookup or master-detail field auto-checks the custom object its referenceTo names — Add only, since the reference needs the object to exist and an Update of that object's definition gives it nothing — and, on both Add and Update, the custom fields its lookupFilter names in Object.Field form; a filter field written as $Source.Field__c is left alone. A lookup field that points at its own object (a hierarchy) still checks the object's Add row but never its sibling fields. A roll-up summary field auto-checks the custom field it summarizes (summarizedField) and every custom field its summaryFilterItems name, on both Add and Update — the target refuses a roll-up over a field it does not have (no CustomField named … found, Invalid Field: …, measured live on 2026-09-16), and it refuses that even though the Tooling dependency graph never reports this reference — and, on Add only, the custom master-detail field its summaryForeignKey names; a standard summarized field, filter field or foreign key (QuoteLineItem.QuoteId) is never selected, and the child object's definition row and the field rows it references reach the table through the same manifest widening as the cascades above, only when the source is an org. Mind one difference from the lookup rule above: when the child object itself is missing from the target, only the fields the roll-up references arrive with it, not the object's other fields — pick that object yourself when you want the rest. A custom metadata record (Type.Record) auto-checks its own Type__mdt on Add, and on both Add and Update the custom fields its values blocks fill. All four widen the session manifest the same way the cascades above do and under the same limit — only when the source is an org — a namespaced object or type is never created or checked (its own unmanaged custom fields still show up, the same rule as elsewhere in this document), a No change row is never checked, a row the comparison table does not already carry is never created by an edge, and none of the four runs backwards: checking a field never checks the decision table that reads it, and checking a decision table never checks the procedure that calls it. A Permission Set Group also widens the session manifest itself: a permission set its document lists — the plain permissionSets entries and the mutingPermissionSets entries alike — that the manifest does not already carry gets a member added for it automatically, the same manifest-widening mechanism the object-child cascade above uses, so the set gets its own comparison row without you having to pick the Permission Set type yourself. Like that widening, this one runs only when the source is an org; with a repository source the manifest is never widened this way, and a permission set named only by the group's document gives no row unless you selected it yourself. Unlike Context Definition and the global picklist edge, the group's own cascade keeps to the ordinary Add-only rule above: checking the group's own row auto-checks only the Add rows of the sets it lists — a set the target is missing, and that the group genuinely needs created — never an Update row of a set the target already has, and every one of those checkmarks can be removed like any other. A set already present in the target needs no checkmark to keep the group's reference to it: what the target actually has is asked again, from the target itself, right before the deployment (see below), so the reference to an existing set survives the deploy without that set's own document ever being sent — deploying it would replace the whole existing Permission Set in the target, user permissions, license and application visibilities included, from a single checkbox on the group. The cascade runs one way only: checking a permission set never checks the groups that contain it, because a group is a separate component rather than the set's container. A namespaced permission set the group names — one belonging to an installed package — is never widened into a row, exactly like every other namespaced component; nor is a name the source org itself does not have.

A custom application auto-checks the Lightning pages its own document assigns or uses as its utility bar (decision of 14.10.2026): every page that a Flexipage entry of its actionOverrides or profileActionOverrides names, and the page its root <utilityBar> names (the target refuses the application with In field: utilityBar - no FlexiPage named <page> found, measured 14.10.2026 when it lacks that page), on Add only — the target refuses the whole application over a page it does not have (The Person_Account_Record_Page Lightning page doesn't exist or isn't valid for overriding the View action., measured live on 2026-10-14), while a page the target already has needs nothing from this deployment. Like the cascades above it widens the session manifest only when the source is an org, so the page's row joins the comparison by itself — with a repository source select the page under Lightning Pages; a page the target already has, changed or not, gets no checkmark and stays out of the table unless you selected it yourself — when the target is an org, the comparison lists the target's Lightning pages once and asks for only the pages that listing lacks (when the listing fails, every page of the application is asked and a warning says so). A namespaced page is never followed, a page name that is not a valid member name is named in the dependency warnings, and the cascade runs one way only: checking a page never checks the applications that assign it. A page assigned only to profiles the target does not have is auto-checked too, because the comparison does not list the target's profiles; the deployment leaves those assignments out of the application, so the page is created unassigned — uncheck it if you do not need it.

The same custom application also auto-checks its custom tabs and record types (decision of 14.10.2026): the Add row of every custom tab its <tabs> lists and of every record type that a <recordType> of its profileActionOverrides names — the target refuses the whole application over a tab it lacks (In field: tab - no CustomTab named <tab> found) or a record type it lacks (The value you specified for RecordType is invalid or doesn't match the object you specified.), measured 14.10.2026. A tab of a custom object also checks that object's Add row when the target lacks the object, because the target refuses the tab without it — together with its fields, each removable (the object travels whole, as a lookup's target does) — and only when the tab's own row is Add: a tab the target has needs no object. With an org source these rows join the comparison by themselves — a record type alone, never its whole object; when the target is an org, the comparison lists the target's tabs and record types once and asks only for the ones that listing lacks (when a listing fails, every name of that type is asked and a warning says so). A tab, record type or Lightning page the target org already has is not named among the references that have no row, with an org source and with a repository source alike, as long as the target's listing of that type could be read; when it could not, the names stay in the warning. Standard tabs (standard-Account) and namespaced names are never followed, PersonAccount.<Name> keeps its document name as the row and manifest member (the target's listing calls it Account.<Name> and is compared under that name; measured 15.10.2026), and a name that is not a valid member name is named in the dependency warnings.

The offline cascades also say when they could not follow something. A source document the plugin cannot parse is reported once, naming the component, and a document that references components that have no row in this comparison is reported once per referencing row, naming up to ten of them plus a count of the rest — except a Permission Set Group's own references, which the deploy resolves against the target itself, and any packaged end, which no cascade follows; and only for rows that have something to transfer, so a No change row's own missing references are never reported. Both notices appear in the comparison's dependency warnings; neither claims to know why the reference has no row — against a repository source it usually means the type was not selected, against an org source that the source org does not have it.

If the Tooling API object is unavailable — the Beta feature is off in the org, or the query fails — the comparison still completes exactly as before: no Tooling-sourced row is auto-checked and the screen shows Dependency auto-selection is disabled with the reason. The two offline rules still apply — a field still pulls in its missing target object, and checking a new object still checks its own field rows. The plugin never blocks a comparison because of this feature. Because the Salesforce dependency graph has known gaps, a missing edge does not prove there is no dependency; the deployment validation stays the source of truth.

The comparison may pull extra components into itself to resolve a dependency. That expansion lives only in the comparison — Back returns your original selection screen untouched. Only the rows something you asked for actually needs are shown: a component pulled in this way gets a row when it is reachable over dependency edges from a row of your own selection, and the row's own Diff column names the row that required it in either state it can be in — as the row's summary before it is auto-checked, and as its added as dependency badge once it is, where the summary no longer repeats the required by clause that the badge already says — instead of a separate list. Everything else the expansion downloaded stays out of the table — to work on such a field, select its object on the selection screen explicitly. A parent whose name equals the row's own name is written with its type in parentheses — added as dependency of Vehicle__c (CustomTab) — so a row never reads as if it were added by itself.

Row Difference View

Double-click any row in the comparison table to open a side-by-side diff of the component's Salesforce DX source-format file: by default the target org on the left and the source org on the right, the way a diff shows the base on the left and the working change on the right; the Diff pane order setting (see Settings and Session Log) swaps the two sides. The view is built from the metadata already retrieved for the comparison, so it makes no additional org calls. For an Add row (or a row whose target object is missing) the target pane shows that the component is not present in the target. Complex components such as a CustomObject show only their object-level source (the source format keeps each field in its own file), never an enumeration of their fields.

For a Context Definition or Decision Table row the target pane shows the target's document in the source's order: each block the source also has — a node, an attribute, a mapping, a table parameter — is moved to where the source has it, a block only the target has stays where the target holds it, and nothing inside a block is added, removed or edited; only the order of blocks changes. The pane's title then reads <alias> (in the source's order) instead of the target's alias. When the row carries an edit, the target follows the order of the edit. Neither the target's file nor the target org is changed; a document that cannot be read as XML is shown as it is, and a target already in the source's order keeps its plain title.

The Review Differences screen beside the diff viewer, with a draft edit typed directly into the source pane

The three code types — an Apex class, an Apex trigger and a Visualforce page — are two documents each, the body and its *-meta.xml sidecar, so a double-click on such a row can open two windows. The sidecar window opens when the row has attribute differences — which is what a change to a sidecar attribute produces: the API version, an Apex class or trigger status, a Visualforce page label — and the sidecar itself could be read from at least one of the two orgs; the body window opens whenever the sidecar window does not, or when the body itself differs as well. A row that differs only in its API version therefore opens one window — the sidecar; a row that differs in both opens two, the sidecar first and the body focused over it; an Add row, a No change row and every row of every other type open exactly the one window they always did. The rule never resolves to zero windows: where the sidecar window is not opened, the body window is. Both panes of the sidecar window are read-only in both clients, which is the editing rule below made visible: an edit never replaces the sidecar. Deploying the row still sends the sidecar — that is how an API version difference reaches the target at all.

The source pane of the Row Difference View — on the right by default, on the left with Diff pane order set to Source left, target right — is editable in both clients while the Allow editing metadata in the diff view setting is on (orgbench.allowSourceEditing in VS Code), so you can narrow what the deployment sends down to your own increment instead of the whole current document of the source org. Which rows offer it is decided by the core, not by the client, and travels with the row, so both clients agree by construction. Seven rules bound that:

  • What can be edited is the document that belongs entirely to one row: a metadata XML document such as a custom field, a custom object or a whole page layout, or the body of an Apex class, an Apex trigger or a Visualforce page. Everything else opens read-only — the *-meta.xml sidecar of those three code types, a Lightning or Aura bundle (the window shows a synthesized concatenation of the bundle's files, which exists on no disk), a rule or a custom label that shares one file with its siblings, and a single layout, Lightning page or report type element in the Select elements to merge mode, where a row is a fragment of a document rather than a document. A row with no change to deploy and a row blocked for any reason are read-only too. For the three code types an edit replaces the body alone, so it can change neither the API version nor whether a trigger is active. Deploying the row does send that meta file; what an edit cannot do is change it.
  • An edited row is marked Edited in the comparison table, and the mark comes from the core rather than from the editor, so it is always visible before the deployment.
  • Editing the document of an object that does not exist in the target yet sends that document as you edited it. Without an edit such a row is created from a minimal synthesized document instead, because the full source document names layouts, list views and buttons the target does not have yet; editing the row hands that choice to you, for that row and that comparison only.
  • An edit is always removable: Revert edit in the row's context menu of the IntelliJ plugin, and the Orgbench: Revert Edit command in VS Code, give the deployment the source content back; text byte-identical to the original clears the edit by itself. Retyping the original is not always byte-identical, though, so the explicit action is the reliable one in either client: the IntelliJ editor normalises line endings, and the VS Code editor, while it keeps the endings it loaded, still folds a body that mixes them into the dominant one and drops a leading byte-order mark.
  • An edit lives only inside the current comparison: it is stored in that comparison's private temporary folder and disappears with it when you press Back or New Comparison. It survives neither an IDE restart nor a new comparison.
  • An edit never widens what gets deployed: it does not select a row, it does not make a blocked row deployable and it creates no rows. A component reaches the target exactly when its row is selected, as without the feature.
  • An edit has a size limit, and the limit belongs to the form of what the row carries rather than to the feature: a code body — an Apex class, trigger or page — is accepted up to 1,000,000 characters, the order of Salesforce's own limit on one class, while a metadata document is accepted up to 16,777,216 characters, a bound that comes from the plugin's own transport frame and from no platform rule. Longer text is refused before anything is written and the refusal names the limit that applied to it. Megabyte-sized documents are therefore editable — a real org's Context Definition routinely is one.

An edit is picked up while the window is still open — you do not have to close it. About a second and a half after you stop typing, the edited document is sent and the row picks up its Edited mark; anything not yet sent is sent now when you press Next or a deploy button on the comparison screen, before the deployment starts. Closing the window still sends it too. In VS Code the draft is saved as you type, so its tab never shows unsaved changes and VS Code never asks whether to keep them — that save is local to the extension and has nothing to do with the deployment. What tells you the core has taken the text is the Edited mark on the row; when the core refuses it, the reason is shown as a warning. Typing the original text back reverts the edit, and Revert edit on a row whose window is still open resets that window back to the original without closing it, so the edit can be started over.

Reopening the window shows the already edited text, so an edit can be continued; the target pane is never editable. While the source pane is editable, its title reads <alias> (draft — org not modified) rather than just the source org's alias, so it never looks like you are editing the source org directly — in VS Code that text is part of the diff tab's own title, because the two panes of a vscode.diff editor carry no captions of their own. The draft is held in memory by the extension and never written to your disk; it goes away with the comparison.

Describe differences with Claude Code puts a plain-English account of a row's differences next to the diff, written by Claude Code on your own computer. It is off by default: until you turn on the setting of the same name (see Settings and Session Log), no row offers it and nothing is read, started or sent. With the setting on, the context menu of a Flow, Apex class or Apex trigger row with status Update offers it; other rows do not, and while another operation keeps the comparison screen busy the menu is not available. Choosing it hands the target's and the source's version of that one component — exactly the two documents the diff view shows, your edit in the diff view included — to the local claude -p through its standard input, with its tools switched off, and Claude Code sends them to the model provider it is set up for (Anthropic by default). The prompt carries no alias, repository name, branch, path or token. While Claude Code answers, the comparison screen is busy with the progress line Describing differences with Claude Code and Cancel, which stops Claude Code and keeps the comparison and your selection as they were. The answer opens in a new read-only markdown tab whose header names the component, both sides and the model that answered, says that the text was written by AI, and says when it describes your edit; choosing the item again asks Claude Code again and opens another tab. A refusal stays on the comparison screen and names its cause and what to do: Claude Code was not found, could not be started, is too old for the options the plugin runs it with, refused itself (not signed in, a document too long — its own text is shown), did not answer within 10 minutes, or answered in a form the plugin does not understand. Nothing changes in any org or repository.

Progress Details

While an operation runs, the status text is joined by a live progress line: a spinning indicator, the current phase, the step counter where the number of steps is known, and the elapsed time since the operation started, followed by a bar that fills when the step count is known and runs indefinitely when it is not. The facts come from the core — it is the only layer that knows which Salesforce CLI command is running — and the line carries metadata type names, org aliases and counters only; CLI output is never shown there.

Examples: Loading objects from dev · 4s, Querying dependencies — 3 of 7 · 12s, Deploying the package · 1m 8s, Checking the target: Product2 records of uat — 15 of 35 · 41s, Checking the target: Product2 in uat — 16 of 33 · 31s. The target health check before a record transfer counts one step per object schema, per catalog and per object read from either org, plus one for the candidates of duplicates (duplicate candidates of uat), and names each org by the alias you picked on the selection screen — the same name the comparison screen shows in its header. Check target counts one step per Revenue Cloud registry object, in the order of their API names. The step count is a live estimate: while dependencies are queried it can grow as the core splits an oversized batch, so 3 of 7 may be followed by 4 of 9.

When one deployment — in any deploy mode, or a Re-Deploy — sends more than one Metadata API package (decision tables one by one, the pricing recipe step, the package of pricing procedure versions, a Best Effort retry), the package line counts them: Deploying the package — 2 of 3 · 1m 8s. The count is that deployment's plan, known before the first package leaves; a Best Effort retry is added to the number of packages at the moment it starts (a retry before the table step turns 1 of 2 into 2 of 3), a step that is held back or not sent takes no number, and a deployment of one package keeps the line without a counter. While a deployment into an org runs, a Deployment Status link right of that line opens the target org on Setup → Deployment Status (lightning/setup/DeployStatus/home) in your browser through sf org open, where Salesforce shows the progress of the deployment job itself; a git target has no such link, and a refusal of the CLI is shown on the deploy screen while the deployment goes on.

Some steps run without leaving the screen you are on. The screen that started such a step stays where it is, disables its buttons and shows the same live line, and Cancel stays available. These steps are: on the selection screen, creating an org alias with the + button, Prepare Orgs (both the inspection before its confirmation and the preparation itself), Check target and Import Session…; after Deploy on the comparison screen, checking the target (when a product bundle row is checked), listing the Apex test candidates (when the package contains Apex or Flow and the target is an org) and matching permission containers (when the permission transfer is not "Do not transfer permissions"); matching permission containers after you confirm the tests on the Apex test screen; on the Target health check screen, Re-check, Fix — deleting the checked records (Deleting PricebookEntry records of the target · 3s) and then checking the target again — and the Apex test listing or container matching that Deploy and Deploy without fixing start there; and, on the Deployment Results screen, checking the target before a Re-Deploy of a product bundle row.

The line is always shown, in both clients, and there is no setting that turns it off. If no progress event ever arrives (a core that does not implement the channel, or a client that asked for it to stay off at startup), the screens behave exactly as they did before: the static status text and the Cancel button.

Settings and Session Log

The permission transfer mode is a setting, not a control on the review screen. In the IntelliJ plugin it lives in Settings | Tools | Orgbench, reachable in one click from the gear button in the tool window; in the VS Code extension it is orgbench.flsMode, reachable from the gear icon in the view title. Because it is a setting, it no longer resets with every new comparison: a mode you chose once stays chosen. The review screen therefore always shows what the next deployment will do as a read-only line, for example Permissions: Additive. The deployment mode is not a setting at all — the last step of the wizard offers three buttons and you choose the mode by pressing one of them; see Deployment Behavior.

The core writes a session log — one JSON object per line — that answers two questions: how long an operation took and what it was made of, and what exactly failed when you need to file a bug report. Each line carries a timestamp in two forms — the local time of your machine first, written as 2026-08-18T14:24:19.332, and the same instant in Unix milliseconds after it — an event kind and an operation id. The line that answers "where did the two minutes go" is operationFinished: it carries the operation kind, its duration, how many calls to the Salesforce CLI and to the Salesforce APIs it made and how many milliseconds were spent inside them. A cli line records one sf invocation: the subcommand, the target org alias, the duration, the exit code, the byte lengths of stdout and stderr, and — on failure — the same sanitized diagnostic the UI shows. A direct request to a Salesforce API is a cli line too, one per HTTP request (each page of a query and each repeat counts): its command starts with api — api query, api tooling query, api list metadata, api describe, or api rest with the method and the path without record ids — and it carries no exit code, no argument list and no URL, and its stdout length is the byte length of the response body. A deployment that finishes normally, even one with rejected rows, is not itself an operation failure — the process's own exit code is 1 and operationFinished reports it as a routine end — so a separate deployOutcome line, written for every deployment and quick deployment right before the result screen, answers "which components were rejected and why". At the Standard level it carries only the counts — total, succeeded, failed, not attempted, and, when the deployment transferred permissions or ran Apex tests, those counts too. At Detailed it additionally names every rejected or not-attempted row: its type, name, operation and the same sanitized message the results table shows, and does the same for every permission- transfer row that did not update its target — capped at 50 rows each, with the remainder counted rather than dropped silently, because a package can carry hundreds of components. An operationCancelled line covers two distinct reasons and does not distinguish them in its fields: either the user chose Cancel, or the core force-aborted the operation after its cleanup failed.

Allow editing metadata in the diff view is on by default in both clients; in VS Code it is orgbench.allowSourceEditing, a key kept from the narrower setting it replaces so that a cleared box survives the upgrade. It decides whether the source pane of the Row Difference View can be edited for the rows that offer it at all — a metadata XML document, or the body of an Apex class, an Apex trigger or a Visualforce page; a sidecar, a bundle, a container document and a layout or report type element stay read-only either way. Turning it off does not erase edits that already exist — it gates the pane, not the deployment — so an existing edit keeps its Edited mark and its Revert edit action. The two clients keep that action reachable differently: in the IntelliJ plugin Revert edit is an item of the row's context menu and needs no window at all, while VS Code reverts through the draft's own tab, so there a row that already carries an edit reopens editable even while the setting is off. What the setting gates is therefore the first edit of a row; a row already carrying one can be edited further either way. The value is read when a window is opened, so a window already on screen keeps the form it was opened with.

Diff pane order decides which org is shown on each side of a row's diff window, in both clients: Target left, source right is the default, Source left, target right is the order earlier versions used. In the IntelliJ plugin it is a dropdown on the same settings page under Settings | Tools | Orgbench; in VS Code it is orgbench.diffPaneOrder, whose values are targetLeft and sourceLeft. The panes and their captions move together — in VS Code the tab title names the two orgs in the order of the panes — and the *-meta.xml sidecar window follows the same order. It never changes which pane can be edited: that is the source pane, in either order. In VS Code the diff editor's own Revert Block arrow copies a changed block from the target into the draft only with Target left, source right: VS Code copies blocks only from the pane on the left into the pane on the right. The value is read when a window is opened, so a window already on screen keeps the sides it was opened with.

Element-level merge is a setting of the same kind, read at another moment: it is the starting value of the Elements checkbox that every Page Layout, Lightning Page, Report Type and Context Definition carries on the selection screen, and that checkbox decides how the document is compared and deployed. In the IntelliJ plugin it is a dropdown on the same settings page under Settings | Tools | Orgbench; in VS Code it is orgbench.elementMode, whose values are whole and elements. The default is Compare and deploy whole documents (whole): a document you tick starts with Elements unticked — one row per document, compared over the whole document, and a deployment replaces the target document with the source version. With Select elements to merge (elements) a document you tick starts with Elements ticked, which turns on the element decomposition described under Comparison Rules for it, Lightning page assignments included: they deploy into the target's app or object document, a standard app or a standard object receives only the selected assignments, and an assignment the target's app repeats byte for byte is sent once. The setting replaces the earlier Page Layouts setting, and a value chosen there carries over: the IntelliJ plugin reads it while the new setting was never saved, and VS Code reads the deprecated orgbench.layoutMode while orgbench.elementMode is not set at any level. The setting is read when you tick a component and when you import a session file that carries no Elements values (one written before version 5); changing it changes no component already ticked — change that document's Elements checkbox instead. A document that the comparison itself adds to the manifest is always compared whole, whatever the setting. Each document's checkbox is read when you press Compare: to change one while a comparison is on screen, press Back, change it and compare again; a deployment follows the rows you are looking at rather than the current value of the setting or of a checkbox.

Retry rows alone after a Salesforce unexpected error (Best Effort) is off by default in both clients; in the IntelliJ plugin it is a checkbox right under Describe differences with Claude Code, in VS Code it is orgbench.retryUnexpectedErrorsAlone. It decides one thing only: whether Best-effort against an org sends a row that the target still fails with only its generic An unexpected error occurred. … text after a whole-set retry of several rows once more entirely on its own — one extra deployment call per such row (see Deployment Behavior). With it off, such a row's Message names this setting. It is a snapshot taken when you press Compare: switching it changes nothing until the next Compare.

Describe differences with Claude Code — a checkbox right under Diff pane order in the IntelliJ plugin, orgbench.describeWithClaudeCode in VS Code — is off by default. When on, the row menu item of the same name hands the target's and the source's version of one Flow, Apex class or Apex trigger to Claude Code on this computer, which sends them to the model provider it is set up for (Anthropic by default). Nothing is sent until you choose the item. The value is read every time a row's menu opens, so switching it takes effect at once, without a new comparison; the core never learns it. The session log keeps one cli line per run: the command claude -p, no org, the duration, the exit code, the byte lengths of the output and, for a refusal, its sanitized text — the constant arguments only at the detailed level — and never the prompt or the answer.

Metadata categories is a setting of the same kind: it decides which categories of metadata types the Metadata Type dropdown offers. In the IntelliJ plugin it is a list of checkboxes on the same settings page; in VS Code it is orgbench.metadataCategories, an array of category ids. By default only the Core category is enabled, so the dropdown lists exactly the types the plugin offered before the metadata-type expansion. Changing it takes effect on the screen you are already looking at. Queues, public groups and roles are the three types Security & Sharing does not offer yet: their documents carry a member list of the source org, and the plugin does not yet know how to create such a component without it. Other types whose documents reference users or profiles are offered as they are, and a deploy that names a user the target does not have fails that one component in Best-effort mode; in Validate only or All or nothing the whole package fails, as everywhere else. Disabling a category does not clear a selection already made in a type it hides: that selection stays in the session manifest and is still sent to Compare and Deploy, even though the type itself is gone from the dropdown. A line below the manifest summary names every such hidden type and how many of its components are still selected, and choosing Compare while any such selection exists shows a confirmation listing those types and counts before continuing. This is true of both clients, not only the IntelliJ plugin. Like every other non-Core category, the Revenue Cloud category is switched off out of the box, and its items are fourteen pricing metadata types and record rows plus 33 configuration records; enabling it reveals both kinds of item and the Prepare Orgs and Check target commands, whereas leaving it disabled removes them all.

Read orgs through decides how the plugin reads an org — component listings, SOQL queries, object describes and REST sub-resources — and sends the REST record writes of a bundle or model transfer. Salesforce API (faster) calls the Salesforce APIs directly over HTTPS with the session the Salesforce CLI holds for the alias; Salesforce CLI (sf), the default, starts sf for every read instead — slower, but over the CLI's own connection, which is the way out when a proxy or a firewall lets sf through but not direct HTTPS. In the IntelliJ plugin it is a dropdown on the same settings page, right above the session log settings; in VS Code it is orgbench.orgChannel (the Settings editor shows it as Org Channel), whose values are api and cli. It applies at once, with no restart: every read that starts after you change it goes through the new channel, while an operation already running may finish some of its reads through the previous one — both read the same org, so the result is the same. Retrieve, deploy, sign-in and the org list run through the Salesforce CLI either way. The session log names the channel in its first line and records each switch as an orgChannelChanged line.

Three levels are available, chosen in the same place as the permission transfer mode (orgbench.logLevel in VS Code):

  • Off — nothing is written; neither the log file nor its folder is created, and the retention sweep that deletes older logs does not run either.
  • Standard (the default) — every kind of record listed above.
  • Detailed — the same plus the full Salesforce CLI argument list of each call (a direct API request has none). Detailed additionally records the SOQL request text, because it is part of those arguments, and for the same reason it records local file paths such as the retrieve manifest.

The log never records a token, and it records no response body either — with one deliberate exception: when an operation fails, the log keeps the same sanitized diagnostic the UI already shows, capped in length. For a failed Salesforce CLI call that diagnostic quotes an excerpt of the CLI response; for a failure with no CLI call behind it — a malformed package.xml, say — it is the message you see on screen. Otherwise only the byte lengths of stdout and stderr survive, and every recorded argument passes the same redaction the plugin applies to displayed diagnostics. Changing the level takes effect immediately, without restarting the core process.

The file lives under the plugin's own temporary directory, in orgbench/logs, and is named session-<timestamp>-<pid>.jsonl. The plugin keeps the five most recent session logs and deletes older ones; it removes only files matching that name pattern and never anything else in the folder. A session log is capped at 8 MiB, after which a final logTruncated line is written and the session stops logging. The settings page shows the current path and offers Open Log Folder and Copy Path; VS Code offers the same two as commands in the view's overflow menu. The file appears with the first record, so a freshly started session with nothing logged yet has a path but no file.

Deployment Behavior

Only the selected component XML is copied into a clean attempt directory. The plugin does not deploy complete object metadata or unrelated fields; deploying a CustomObject writes only that object's .object-meta.xml, never touching its existing fields or other components in the target.

Creating an object (an Add row of Custom Objects, Custom Metadata Types, or Platform Events) deploys a minimal object document synthesized from the compared attributes plus, for Custom Objects, the required nameField, instead of the source org's full file: search layouts, list views, web links, and action overrides reference components that do not exist in the target yet, and Salesforce rejects the whole object because of them. The compared attributes carry the object's own switches that the source document has — including Enable Search, Enable Sharing and Enable Bulk API — but never its history and feed tracking settings: a new custom object is created with history and feed tracking off, and a new custom field is created untracked (both are described below). A custom setting is the one object shape built differently: the plugin sends only customSettingsType, description, label and visibility for it — the org rejects others by name (Cannot specify: enableFeeds for CustomSettings) — and it has no nameField at all, so that document carries those tags and nothing else. This holds in all three deploy modes — every one of them builds the object document the same way. If a source Custom Object that is not a custom setting carries no nameField, the plugin refuses to package it instead of sending the full file: in Best-effort that one row is Failed with that reason and no deployment call is made for it, while the rest of the selection is still sent; in Validate only and All or nothing the whole deployment fails before any deploy call. An Update row still deploys the source file as it is, and the Row Difference View always shows the real source content of that object. An Add row whose document you edited in that view is the one exception, and it steps outside every rule of this paragraph: it deploys the edited document as it is, for that row and that comparison only. Nothing above is synthesized away for it — the sections that make a full object file fail on creation are still in it unless you removed them, a custom setting carries whatever tags you left in rather than only the four, and the nameField refusal does not apply either: the document is packaged and sent, and anything wrong with it comes back as that one component's rejection from the target instead of a refusal before the deploy: in Best-effort only that component fails, while in Validate only and All or nothing the target's rejection still fails the whole package, as everywhere else.

A Permission Set Group is the first of three types whose document the plugin trims before sending it. Right before the deployment — after any edit of yours and before the package is built — the plugin asks the target which permission sets it has and drops from the group document every permissionSets and mutingPermissionSets entry that is neither already there nor created by this same deployment. Against an org that question is a query over the org's own PermissionSet records, which report managed sets and their namespace exactly as the group document spells them; against a repository it is the set of permission-set files on the target branch — a brand-new branch created from a non-empty base answers with that base's own listing, not «none»; only an empty repository, or a brand-new branch created from an empty base, answers «none» — because the target's own listing of that category does not reach muting permission sets at all against a repository (only profiles/ and permissionsets/ are read there), a mutingPermissionSets reference is not trimmed at all against a git target, on the same «the source does not cover this category, so it is not cut» principle that already applies to a packaged name. A reference is kept for one of three reasons, in this order: the name is already present in the target; the name is created by this same deployment as another selected Permission Set Add row; or, as a last, fail-open belt that only fires when the target's own listing does not cover packaged sets — today that means only a git target, whose branch listing cannot tell a packaged permission set from any other — a name that carries a namespace prefix is never dropped, because a packaged permission set is present exactly when its package is installed and the plugin does not decide that. Against an org target that belt does not fire at all: the org's own PermissionSet query does cover packaged sets (measured on the owner's org — 401 records, covering all 39 references of the live RCA_Admin document, managed sets included), so there a namespaced name is judged exactly like any other and dropped when the target does not have it — closing the gap a live deploy exposed, where the org rejected the whole group with Cannot create Permission Set Group Components since the following permission set names are invalid: … because the previous, unconditional belt had kept managed references the target did not actually have. Everything else in the document is left byte for byte. The group's own row in the Message column of the results says how many of its permission sets were kept and names the ones that were not, so the trimming is never silent; the message states only how many names were kept out of how many and which ones — the plugin does not claim to know WHY a name was not found. A row whose document you edited by hand in the Row Difference View is not filtered at all — the same belt and the same reason as the object-definition placeholder — and the filter only ever runs after an edit has already been applied, never before. The extra question is asked only when the selection actually contains a group, and asking it does not change the progress line. If it cannot be answered, the group is not sent with a document the plugin could not check: in Best-effort that one row is Failed with the reason while the rest of the selection still travels, and in Validate only or All or nothing against an org target the whole deployment fails before any deploy call — against a git target the same failure stays componentwise in every mode, including All or nothing.

That trim still asks the target before the deployment, not after it, so a permission set that the trim kept because this same deployment was about to create it can still fail to create for a reason of its own — a live run against an org found exactly that: two Permission Sets rejected for unrelated reasons, and the group Failed right after them for referencing names that, by then, had not actually been created. Since that run, Best-effort against an org target answers with one extra, narrowly scoped attempt: if a PermissionSetGroup row came back Failed and its own document names a Permission Set that this same run left Failed or Not Attempted, the plugin rebuilds that group's document — the same trim, now excluding the names that did not make it — and sends only the affected group rows again, once, with --ignore-errors and nothing else (no Permission Sets, no permission containers, no Apex tests). The group's row then carries whatever that second attempt returned instead of the first, and its message says a retry happened and which names were excluded either way; if the second attempt itself never reached the target (a timeout, a cancellation), the row keeps its first result. This never happens more than once per group, never happens against a git target (which never makes a metadata deploy call for this in the first place), and never happens in Validate only or All or nothing, where a rejection is already meant to fail the whole package. It also never happens when the FIRST call itself never reached the target, or reached it but was rejected wholesale without naming a single component: neither outcome says anything about this particular group, so retrying would not be responding to the group's own failure.

A Context Definition is the second type whose document the plugin trims before sending it, and the rule is a different one: it removes what the target's own schema does not have. Right before the deployment — after any edit of yours, in the same place the group document is trimmed, and in all three deploy modes — the plugin asks the source org and the target org one question each: which fields the objects this document names actually have. The answer is a single query per org over that org's FieldDefinition, read through the Tooling API, which also lists the fields the CLI user has no access to (the Data API hides them, and the trim would then cut references to fields the target does have; measured 19.10.2026), and it also says which of those objects exist at all, so no second question is needed. What is cut is the DELTA between the two answers, never «missing from the target» on its own: a hydration mapping is dropped when the pair of object and field it names is known to the SOURCE org and absent from the TARGET org, and a context node mapping is dropped when its object is known to the source and absent from the target. A reference the source org does not know either — a relationship name such as Asset.Product2, or a typo in the source document itself — is left exactly as it is, because «we do not know it» is not «the target does not have it»; on the owner's own document that distinction is two thirds of the references. A field or object this same deployment is itself creating — a CustomField, CustomObject, CustomMetadataType or PlatformEvent row you also checked — counts as already known to the target even though the target's own schema was read before the deploy, so the trim never cuts the hydrations you are transferring in this same package. Dropping a hydration mapping takes the mappings nested inside it too, since the outer link is what they hydrate through, and the plain attribute mapping that held it stays; dropping a node mapping takes its attribute mappings with it, and the context node itself is never touched — except that a node mapping the delta would drop stays while, in the same mapping, the mappings of nodes under it stay (Salesforce rejects a node that has mappings under a parent without any: Invalid mapping structure), and the message then says kept N object mapping(s) the target's schema does not list, because mappings of nodes under them stay: …. Everything the trim did not name is left byte for byte, and nothing else in the document — references to other context definitions, inheritance — is ever removed. The row's Message column says how many field references and object mappings were kept out of how many and names what was left out, capped at ten names plus a count, so the trimming is never silent; like the group's message it states facts only and does not claim to know WHY the target lacks a name. A reference removed only because the outer link that carried it was cut — never named by that reference's own trigger — is not named individually, but its count is: the message ends with a clause such as "3 more removed with their hydration chain" whenever that count is not zero. On the row of a single element of a definition (element mode) the counts, the names and that clause cover only the references inside that element, not those of the whole document, so another element's trim is not attributed to it; an element whose references left only with another block's chain gets the text of the whole document, so the reason is never lost. A row whose document you edited by hand is not trimmed at all, the same belt as everywhere else. Both questions are asked only when the selection actually contains a Context Definition, and only when both ends are orgs: a repository branch carries no schema — it does not list a standard object's standard fields at all — so with a repository on either side neither half of the delta rule can be decided and no trimming happens. If a question cannot be answered, the row is not sent with a document the plugin could not check: in Best-effort that one row is Failed with the reason while the rest of the selection still travels, and in Validate only or All or nothing the whole deployment fails before any deploy call. Deploying a Context Definition always creates a NEW version of it in the target — measured live, the same version record's VersionNumber goes up — and never deletes or deactivates the versions already there. A large document — megabytes rather than kilobytes, especially against a freshly enabled Context Service — can take tens of minutes to deploy with no progress shown (21 minutes measured live against a 2 MB document); that is expected, not a hang, though a large enough document can still exceed the plugin's own deploy timeout and end the operation in a failure instead of waiting further. A Permission Set is the third, in Best-effort only, as described under the comparison rules above.

A Context Definition carries one more rewrite before it is sent, and it is not a trim: the release version. Salesforce refuses a context document that was created in a newer release outright — Cannot deploy Context Definition 'ProductDiscoveryContext_Ext' with release version '264.4.11' to an org with older release version '262.14.17' — and that refusal is decided by one tag of the document alone, so right before the deployment — after any edit of yours, in the same place the trims run, in all three deploy modes — the plugin replaces that tag with the TARGET org's own release version whenever the source value is newer. The target's value is read from the documents the comparison already retrieved from the target: the row's own document when the target has that context, otherwise the newest release version among the other Context Definitions of the same comparison; no extra question is asked of either org, because no org reports that version through any other channel. This one runs with a repository as the SOURCE too — a branch document carries the same tag — but never against a repository target, which has no release version to read. A value equal to or older than the target's is never rewritten, a row you edited by hand is never rewritten, and when the target's version cannot be read at all the row travels exactly as it is and keeps the target's own refusal. The rewrite is always visible in the row's Message column, on a Succeeded row as much as on a failed one, and it comes first among the plugin's own notes there — ahead of the hydration-trim note and of the retry marker, and after whatever the target itself said about that row: Release version 264.4.11 rewritten to the target's 262.14.17. It makes no claim about the rest of the document: an element the older release does not know still comes back as that component's own rejection from the target.

Best-effort against an org target answers a rejected Context Definition the same way it answers a rejected group, and for the same reason — the trim asks the target before the deployment, not after it. A deployed context row — whatever its own status, including Succeeded — is also retried, without waiting for a rejection, when its document carries a field or object that this same package was supposed to create but whose own row came back Failed or NotAttempted: a row Salesforce never created is not a field or object the target actually has, so a context document still pointing at it is retried without that reference regardless of what the target said about the context row itself. If a ContextDefinition row came back Failed and the target's own rejection text NAMES a reference the deployed document carries, the plugin rebuilds that document without the named reference and sends only the affected context rows again, with --ignore-errors and nothing else — no other components, no permission containers, no Apex tests. The match is deliberately narrow so that an English sentence cannot trigger it by accident: a field reference matches an exact Object.Field spelling, or the bare field name as a whole word when that name ends in __c, __mdt, __e, __x or __b and it is not itself preceded by a foreign qualifier (a dot and another identifier right before it, which would make it part of someone else's Object.Field pair instead — OrderItem.Pricing_Mode__c never names the bare Order.Pricing_Mode__c pair just because the field name matches); an object matches only its own bare name as a whole word under the same suffix rule and the same foreign-qualifier condition — a lookup field is often named after the object it points to, so My.Product__c never names the Product__c object either — and never the Object. that merely qualifies a field — that pair is already covered by its own spelling, and reading the same text as an object name would drop the whole node mapping of that object, its other hydrations included, over a complaint about one field; a bare standard name such as Order never matches either, because the word is far too likely to appear in a rejection for other reasons. What is matched is the target's own rejection text, never the trimming message the plugin itself put on the row. Both triggers were checked in a live run: the target rejected a document over a many-to-one mapping naming AssetContractRelationship.Contract, the text-based trigger cut that reference, and the target accepted the rebuilt document; the not-created-row trigger fired independently in the same run, on two Product_Family__c rows the target itself never created. What is still NOT known to fire in practice is a narrower thing: Salesforce rejecting a document specifically because a reference names a field or object that does not exist at all — a live check found it accepts such a document unchanged rather than rejecting it, so that one failure shape remains built to a pattern rather than to an observed failure. Each further attempt, from either trigger, happens only when the newest signal named something not already excluded, and there are at most three of them; a rejection that names nothing ends it, and a retry call that fails to reach the target at all leaves the previous result in place — the same is true on the very first call, before any retry, whether the target could not be reached at all OR it answered but rejected the whole package without addressing any individual component: nothing about this row is retried then, because nothing about it is known to be the target's fault. The row's message says a retry happened and what the rebuilt document left out, and the whole retry path — either trigger — never runs in Validate only or All or nothing, where a rejection is already meant to fail the whole package.

Every deploy mode sends the whole selection as one Metadata API deployment, so the Metadata API resolves references between the selected components itself: an object, its fields and its record types travel together and no ordering between metadata types is needed or attempted. The one exception is a selection that changes a decision table this same deployment rewrites from active to inactive next to other rows, or that carries a pricing recipe next to a pricing procedure version (see Decision tables and the version that reads them and The pricing recipe below; never against a git target, and a table is rewritten only against a target whose class the plugin has confirmed — the pricing recipe step has no such condition): Salesforce can fail a deployment that changes several decision tables at once, refuses a version while a table it reads is inactive, and refuses a version whose table the target's pricing recipe does not map, so the selection goes as several deployments, in order — everything else first; then each such table on its own, switched on again right after it; then the selected pricing recipes, when procedure versions are selected; last those versions, every other selected version of the same procedure, its definition row and the rows that depend on them, once the tables are active again. There are no other waves; in each deployment the mode decides what a rejection costs, so in All or nothing a refused deployment stops the ones after it while the ones before it stay deployed (Validate only validates each of them and writes nothing), and the review screen names every version that goes last — the versions of the same procedure that read no such table themselves included, each on its own line — and every table that deploys on its own, and says that the earlier deployments stay if Salesforce refuses a later one. If a later deployment gets no answer (the CLI fails, or Cancel comes while it travels), its rows are Failed with that deployment's own text, the earlier ones stay and the results screen appears. There is one deployment call for the metadata (one per deployment, when the selection goes as several deployments) and, when permissions are transferred, one more for them — plus, in Best-effort against an org target only, the retry calls described above: the one Permission Set Group retry, when a group's row failed because of Permission Sets of the same deployment, and at most three Context Definition retries, triggered either when a context's row failed and the target's rejection named a reference the document carries, or when the deployed document carries a reference to a field or object this same package was supposed to create but did not, and at most three Permission Set retries in TRIM_AND_RETRY, the default, triggered when the target's rejection of a Permission Set row names a user permission or a component reference that row's document still carries (in TARGET_CONFIRMED the same trigger retries at most four times; in OFF the row is never trimmed or retried). When a package also carries real failures, the target may fail the healthy rows next to them with only its generic error — An unexpected error occurred. … — which names no component of its own: Best-effort against an org target answers that with one extra, narrowly scoped attempt after the retries above, sending again, once, only the rows whose failure is that generic text, exactly as first sent, with --ignore-errors and nothing else (no other components, no permission containers, no Apex tests); a row then reports the target's latest text first, with one short retry sentence after it — the original generic error is not repeated, while the plugin's own notes about the document this retry sends again (the trim of a Permission Set, Profile, Permission Set Group or Context Definition, a rewritten releaseVersion, the status note of a Pricing Procedure version, the shell note of a procedure definition and a removed usageSubtype or pricingUsageSubType) stay between the target's text and that sentence — never in Validate only or All or nothing, never against a git target, never when the first call never reached the target or was rejected wholesale, never more than once, and never with a row that has no metadata to deploy. When rows still fail with only that generic text after the whole-set retry, and Retry rows alone after a Salesforce unexpected error is on in the plugin settings (off by default, and read when Compare is pressed), Best-effort sends each such row once more entirely alone — one extra call per row, in row order, with the same narrow arguments; a row then reports the latest outcome first, with one short Retried alone, after Salesforce unexpected error. sentence after it, and the same plugin notes between them; the target's earlier texts and the whole-set retry's sentence are not repeated. A row the whole-set retry got an answer for is sent alone only when that answer is the generic text — the plugin's notes on the row do not count. With the setting off no such call is made: each row the per-row pass would have sent keeps its status and its message and gets one more sentence after it, Turn on Retry rows alone after a Salesforce unexpected error in the Orgbench settings and compare again to send such a row on its own. (except a system report type row that already gets its own advice that a retry does not help, which keeps only that advice). The per-row pass never runs when the whole-set retry sent zero or one row (an empty or single-row first pass — that row already travelled alone), never runs outside Best-effort or against a git target, stops between calls when cancelled while keeping every result reached so far, and gives each row at most these two extra attempts — a pair that fails only together stays failed with the target's last word. Those retries run in that order — Permission Sets first, then the Permission Set Group, then the Context Definitions — because a group's own retry reads which permission sets this run actually created, and a set that arrived on its own retry has to count as created by then. The retries are bounded for each deployment by that deployment's own results; the decision tables, the pricing recipe and the versions of a selection that goes as several deployments get only the generic-error retry (the set, then row by row only when the setting above is on, otherwise the same sentence), because they carry none of the types the other retries are for.

Permission Set repair mode is TRIM_AND_RETRY (As now — trim and retry (up to 3) in the IntelliJ plugin) by default in both clients, as in release 0.1.4; in the IntelliJ plugin it is a combo box on the same settings page, in VS Code it is orgbench.permissionSetRepairMode. It decides one thing only: how a standalone Permission Set row is treated in Best-effort against an org — Off sends the Permission Set document as is with no retry; TRIM_AND_RETRY, the default, trims by what the target reports and retries up to three times; TARGET_CONFIRMED retries only what the target named, up to four times. Like the settings above, it is a snapshot taken when you press Compare: switching it changes nothing until the next Compare. In the element mode a layout's merged target document is prepared right before deployment, and a failure to prepare a selected layout stays isolated to that layout's own rows in Best-effort mode and against a git target, but in Validate only or All or nothing against an org target the same failure fails the whole package before any deploy call; in the default whole-layout mode there is no merge step to fail — the row's own source document is sent as is.

Apex Classes and Apex Triggers travel in the same single package as everything else, so Apex compilation validates the whole selected set together. Apex rows are selectable for any target org. Before deployment, the test screen opens when the package contains Apex or Flow — an Apex Class, an Apex Trigger, or a Flow anywhere in the selection — and the target is an org; a git target never opens it. In that case Next opens a dedicated Select Apex Tests screen. That screen offers only a list of candidate classes with checkboxes — the candidate list combines the Apex classes already present in the target org (namespaced classes excluded) with the @isTest classes being deployed in this very selection, marked This deployment or Target org; only a class whose name contains Test in any case is a candidate at all — the target org's listing carries no annotation, and the @isTest scan of a body being deployed also fires on the annotation named in a comment, so the name is the only test marker the two sides share — and the list is alphabetical and searchable. The classes from this deployment are checked by default — deploying a test class implies running it — and every one of them can be unchecked, including all of them at once; a box you uncheck stays unchecked when you walk back to the review screen and forward again, and the checkmarks are re-seeded only when the candidate set itself changes — most commonly because the selection changed what is being deployed. Deploy is always enabled: an empty selection is a legal choice — a sandbox target then deploys with no tests run at all, but a production target still runs its own local Apex tests and requires 75% coverage when no test level is requested. Checking one or more classes runs RunSpecifiedTests; the checked test class names are passed to the Salesforce CLI as separate arguments (--test-level RunSpecifiedTests --tests <Class> repeated per class), and only names from that published list are accepted. Running every local test in the org is not offered as an option. The chosen tests run once, in the single deployment that carries the package, in every mode. A Re-Deploy reuses the tests chosen for the deployment it repeats and opens no screen. When a deployment is rejected for insufficient code coverage, the target's own coverage warnings are read from the response and matched to the class they name: that class's own row gets a personal message with just its warning text, for example Code coverage: Test coverage of selected Apex Class is 0%, at least 75% test coverage is required, while any other row of the same rejected package gets the shared rejection text — the same reply, still naming every flagged class — for example Code coverage: MyClass: Test coverage of selected Apex Class is 0%, at least 75% test coverage is required — instead of a bare status word.

Because there is one deployment call, what a failure costs depends on the mode. In Best-effort the call carries --ignore-errors, so Salesforce commits the components it accepted and names the ones it refused: those rows are Failed with the target's own text, and every row Salesforce did not name is Succeeded. When the response contains failures that could not be matched to any requested component, the unnamed rows are reported Failed too rather than guessed successful. In Validate only and All or nothing the package is atomic: any rejection fails every row, and the non-culprit rows carry a transaction-rolled-back message. A connection failure — the target never answering at all: authentication, authorization, CLI, network, an unrecoverable timeout, a malformed or missing response, or a job that never reaches a terminal state — fails the whole deployment in every mode, and so does cancellation. The plugin uses --ignore-errors in Best-effort only, and never against a production org nor in any other mode; it does not delete target fields or perform a destructive deployment, and it creates a target object only when you explicitly select that object's deployable CustomObject row. The separate permission step that follows the package has its own, more forgiving failure handling — see Permission Transfer Modes.

At comparison time, the plugin records both aliases, usernames, and org IDs. Before deployment it reloads the aliases and rejects the operation if either alias no longer resolves to the reviewed username and org ID. Salesforce operations within the reviewed session use those stable usernames rather than trusting a later alias reassignment.

The mode is not a setting: the last step of the wizard offers three buttons — Validate, Deploy and Best Effort, in that order — and you choose the mode by pressing one of them. Which screen is the last step depends on the selection: the review screen when neither the Apex test screen nor the permission container screen follows it, otherwise whichever of those two comes last. None of the three is the IDE's default button, so pressing Enter never starts a deployment. Against a production org the Best Effort button is not shown at all — it is not disabled, it is absent — and only Validate and Deploy remain, because a partial deployment is not something a production org accepts; the plugin asks the target org which kind it is at comparison time, and when that question cannot be answered the button stays available. Against a git repository target there is a single Deploy button, because a repository target has no deploy modes. The three buttons map one to one onto the three behaviors below:

  • Best-effort deployment sends the same single package with sf project deploy start --ignore-errors, so Salesforce keeps every component it accepted and reports the ones it refused. Permissions are transferred afterwards, in a separate deployment, and only for the rows that actually succeeded; that step's own non-cancellation failures are contained rather than fatal to the metadata report (a cancellation still stops the whole operation; see Permission Transfer Modes). Partial success is allowed. This is the one mode that is never available against a production org — Salesforce refuses --ignore-errors there as a whole (rollbackOnError option must be true on a production org) — so the Best Effort button is not shown there, and when the target's class cannot be determined the button stays available as described above. If Salesforce then refuses such a deployment as a production org, the results screen says so above the tables — Salesforce accepts only all-or-nothing deployments in this org (it is a production org). Nothing was changed. Re-Deploy runs as Deploy. — the rows keep the target's own text, no retry is made, and Re-Deploy runs as Deploy. One rule narrows "reports the ones it refused": Salesforce deploys every field and every object-child component (a list view, a validation rule, and the other object-child types) of the SAME object as a single Metadata API component, so rejecting one rejects all of them, whether or not the response names the others by name — a field or object-child row is never reported Succeeded when a sibling of the same object was named Failed in that response.
  • Validate only builds the same package but calls the CLI with sf project deploy start --dry-run, so nothing changes in the target org. Results report Would succeed / Would fail instead of Succeeded / Failed.
  • All or nothing sends every selected component of every type plus the merged permission changes in one atomic Metadata API deployment — or, when Salesforce needs a decision table, a pricing recipe or procedure versions deployed separately (see Decision tables and the version that reads them), in several deployments, each rolled back on its own failure while the earlier ones stay, which the review screen says before you deploy; any failure rolls back the whole deployment it hits (rollbackOnError is on by default), and non-culprit rows are reported failed with a transaction-rolled-back message.

Deploying to a production org. Against an org the plugin recognizes as production there is no Best Effort: the last step offers Validate and Deploy only, and above the buttons a Deployment plan names the steps Deploy will take for the rows checked right now. Deploy runs in phases and never starts a phase before the previous one succeeded: (1) the metadata — every selected component, the definition of each selected constraint model and the permission changes — goes as one atomic Metadata API deployment that Salesforce applies whole or not at all; right after it the plugin activates again the decision tables it sent inactive and activates the pricing procedure versions it sent inactive, and step 1 counts as succeeded only when the package and every one of those activations did — otherwise nothing further starts and the bundle and model rows say Not started: activating the deployed decision tables and pricing procedure versions did not succeed — see their rows.; when the selection changes a decision table that step 1 switches off next to other rows, or carries a pricing recipe with a procedure version, step 1 is several atomic deployments — the rest; each such table on its own, activated again right after it; the pricing recipe; the procedure versions — each with the selected Apex tests, and the Deployment plan says Metadata: several deployments, in order — …, naming only the deployments this selection makes (the procedure versions, which then become active when the plugin activates them); a refused deployment stops the ones after it while the ones before it stay in the target, which the review screen says; when a table's own deployment is refused the bundle and model rows say what they say for any refused step 1 (Not started: the metadata deployment did not succeed, so records were not transferred.), and when the versions' deployment is not sent or is refused they say Not started: the second package (procedure versions) did not deploy — see their rows. (and when no versions follow, a decision table that went on its own and whose status could not be read after its own activation stops them with the activation text above); (2) only after it succeeded, the Target health check fix runs first, if you chose it, and then the product bundles are transferred as records; (3) last, for each selected constraint model its tags, its constraint model text and the activation of its version, once every bundle its tags refer to has been transferred. When the metadata deployment does not succeed nothing else starts: a bundle row says Not started: the metadata deployment did not succeed, so records were not transferred., and a model row keeps the package's outcome with Tags, constraint model and activation were not applied: the metadata deployment did not succeed. added; when a bundle is not transferred, the model that tags it stays Failed with the bundle's name and its definition in the target as Inactive, and once the cause is fixed Re-Deploy finishes it. A cancellation after the metadata deployment succeeded ends on the results screen, not on an error: the metadata rows keep their result and the rest say Not started: the deployment was cancelled after the metadata deployment succeeded. Validate checks step 1 only, without changing the org — the bundle and model rows say Validate checks the metadata deployment only; records and model steps run on Deploy. — and is not offered for a selection of bundles alone; Quick Deploy after such a validation runs step 1 from the validated job and then steps 2 and 3. With a product bundle in the selection Validate first shows the Target health check, where Fix during Deploy deletes nothing and neither does Validate: the marked findings are deleted when you press Quick Deploy, after the validated metadata deployment succeeds and before the records are transferred, and that deletion cannot be undone. Without a bundle Validate goes straight on, without the check. Quick Deploy checks the target again before deleting and deletes only findings that are still there. Records cannot be rolled back, which is why they wait for the metadata.

All three modes take the same path — one deployment for the whole selection, or several when it goes as several deployments (see Decision tables and the version that reads them) — and differ in the flag that deployment carries — --dry-run for Validate only, nothing for All or nothing, --ignore-errors for Best-effort — and, when the selection goes as several deployments, in what a refused one does to the ones after it: in All or nothing it stops them, while Best-effort and Validate only send every one. The plugin uses --ignore-errors in Best-effort only, and never against a production org, and it never deletes target components. The test screen offer is the same in all three modes — it opens once, before the selected mode starts, whenever the package contains an Apex Class, an Apex Trigger, or a Flow and the target is an org — and the chosen tests attach to that one deployment — or, when the selection goes as several deployments, to each of them, so against production the tests you chose run once per deployment (with none chosen no deployment asks for tests, and Salesforce applies its own rule to each). In Validate only the package really runs the chosen tests and nothing is written to the target, including against a Flow-only package. In All or nothing a failing test rolls back the whole package, including against a Flow-only package. When tests ran, the results screen adds a Tests: N run, M failed line, and failed test names with their sanitized messages are visible in the operation's details in every mode, not only when the deployment operation itself failed. In Best-effort, a failed Apex test does not stop the deployment: --ignore-errors still commits every component Salesforce accepted and those rows still report Succeeded, while the failed tests' names and sanitized messages are visible in the details alongside them. In Validate only and All or nothing, a failed test still fails the whole package, exactly as any other rejection.

In Best-effort against an org target, and only there, a Profile document is trimmed before it is sent — by two rules. The first is the Permission Set rule above, unchanged: a userPermissions entry whose permission the source org's describe knows and the target org's does not. The second covers the twelve kinds of reference a profile carries — field and object permissions, class and page access, tab visibility, record type visibility, layout assignment, application visibility, custom permission, flow access, custom metadata type and custom setting access: a block is removed when the target org does not know what it points at. The target is asked about itself, one question per kind the document actually carries, so a Best Effort deploy carrying a Profile asks the target eight metadata listings plus the standard-tab query — up to nine questions — plus its object schema before the package is built. A packaged layout, application, custom permission or flow is never removed, because the target's own listing of those four kinds does not report packaged components at all — "not listed" there does not mean "not there". A reference this same deployment creates or updates — a field, an object, a class or any other component travelling as its own row of the same package — counts as known to the target, for a Profile exactly as for a Permission Set: one rule for both types. What was left out is named in the row's Message column, on a succeeded row as much as on a failed one, and the message states counts and names only.

If the target still rejects a Profile row, the plugin reads its wording and sends that row again without what the target named — at most five more times. It recognizes exactly four forms: an unknown user permission by name, a missing reference by its tag and name, a permission the target refuses to change on a standard profile (named by its label, which the plugin resolves through the target's own describe), and a permission that depends on another one (the dependent permission is removed; the ones it depends on are never added, because that would deploy more than you selected). Anything else is an honest failure of that row. The retries run in a fixed order — Permission Sets first, then Profiles, then Permission Set Groups, then Context Definitions — and each retry carries only the affected rows, with no Apex tests and no permission containers. In Validate only and All or nothing neither the trim nor the retry happens at all, and a repository on either side disables the trim for the same reason it disables the Permission Set one.

Rows with an error (Failed / Would fail) come first in both tables, then Not Attempted, then the rest, each group in the order the deployment reported; clicking a column header sorts as usual.

Quick Deploy appears on the results screen after a successful Validate only run against an org — and only when that validation actually ran Apex tests, because Salesforce refuses to quick-deploy a validation that ran none. Pressing it deploys the very package Salesforce already validated, without uploading anything again and without re-running the tests: the plugin passes the job id of the validated deployment to sf project deploy quick. The job is single-use — once quick-deployed it cannot be quick-deployed again — and Salesforce keeps it for ten days, but the plugin does not remember it between sessions: the button lives only on the results screen of the validation that produced it. When the validation succeeded without running any tests, the results screen shows a single line saying so instead of offering the button; because the test classes riding in the package are checked by default — those whose name carries Test, the only ones the screen lists — a validation of a package that carries one normally does run tests and so normally produces a quick-deployable job. After a validation that did not pass, the line says that the validation did not pass and points to the rows with an error at the top of the tables. Quick Deploy adds no new deploy mode: its results are reported as a normal deployment (Succeeded/Failed, not Would succeed/Would fail), because the package really is written to the org, atomically. The notes that the validation produced for its components — the Record Detail replaced by Dynamic Forms, the forecast of a Context Definition sync — are added to the Succeeded rows of those components in their deploy form, because the answer of a quick deploy names components, not comparison rows. A validation of a selection that goes as several deployments offers no Quick Deploy at all — Salesforce cannot quick-deploy a later validation once an earlier deployment has landed — a decision table validated on its own starts with Validated on its own., and the rows of its second package say Validated in a second package: Quick Deploy is not offered for this validation, because Salesforce cannot quick-deploy the second package after the first one lands — deploy the selection instead. and the results screen gives the cause in place of the button (Quick Deploy is unavailable: this validation ran as several deployments, and Salesforce cannot quick-deploy a later one after an earlier one lands — deploy the selection instead.; the same against production)

Re-Deploy sends the rows you checked on the results screen as one new deployment, in the same deploy mode as the deployment whose results are shown. Both result tables carry a checkbox column whose header checkbox checks every visible row that can be deployed again; Re-Deploy stays disabled until at least one row is checked, and its tooltip then reads Select the rows to deploy again. Only rows the target did not accept can be checked — Failed and Not Attempted rows, and after a Validate only run that was not quick-deployed every row except a Skipped permission. A row the deployment already changed in the target cannot be checked, and its tooltip names the reason the plugin core gives (Already deployed. Run a new comparison to deploy it again.): its comparison row is stale — an Add has become an Update — and the safety rules for creating an object or a Permission Set rest on that Add. Checking a permission row sends the component it belongs to and that row's container, and every checked container receives the permissions of every component of the repeat package — the cross product, as in any deployment, not only the checked pair; there is no permission-only retry. Nothing else joins the package — no dependency auto-selection and no component of the earlier deployment you did not check. A field whose new object this comparison's deployments already created repeats without that object: the object counts as present in the target. A field whose new object has neither landed in this comparison's deployments nor has its own row checked is refused before anything is deployed: nothing is sent, the results screen stays as it was with your checks, and the plugin core's reason appears under its buttons — Missing target object '<object>': select its object row or deselect its fields. — until you change a check; check the object's row or uncheck the field (or its permission row), and press Re-Deploy again. Any other refusal of the checked rows themselves is shown the same way, on the same screen. The Apex test screen and the permission container screen are not shown again, and the chosen tests travel only when the repeated package itself carries an Apex Class, an Apex Trigger or a Flow. The deploy mode is the one the repeated deployment was started with: after Quick Deploy a Re-Deploy runs as Validate only again and carries the validation's permission mode and containers, since a quick deploy reports no permission rows — it changes nothing in the target and, when the validation runs Apex tests, offers Quick Deploy once more. A repeated Product Bundle row goes through the target health check again, exactly like a deployment from the comparison screen; while that check runs the results screen shows it as busy, with its checkboxes and buttons unavailable and Cancel ending on the error screen. The comparison stays open while the results screen is shown — an edited document is sent again as you edited it — and closes when you leave that screen: New Comparison, cancelling, closing the tool window, or an error. A Re-Deploy refused by the deploy-mode or the license gate — Best Effort against production, the license — ends on the same error screen, with the same text, as the first deployment would.

Revenue Cloud pricing configuration deploys by the same rules, and the offline cascades of the Dependency Auto-Selection section are what make one checkbox enough: a Pricing Recipe brings its pricing procedure and the decision tables it maps that the target does not have yet, a procedure version the Pricing Recipe (Update, against an org target) whose target copy does not map a table it reads, a procedure its tables and its context definition, a context definition the custom fields and objects it hydrates from and the other context definitions it maps a node to or references, a dataset link its table and its custom source object and, when the target lacks that object, the object's new fields. The whole selection still travels as one Metadata API package (the one exception follows in Decision tables and the version that reads them), so the target resolves the references between a procedure, its tables and its context inside that package; a decision table's rows are records of its source object and never travel with the table's definition. A Context Definition is trimmed to the target's schema and retried in Best Effort exactly as described above, and a Permission Set Group is trimmed to the permission sets the target has. A pricing procedure travels as a version (ExpressionSetDefinitionVersion), not as its definition: the definition document carries every version the source ever had, and the target refuses to change the version it runs as active. When the target has no such definition at all, the version's own cascade checks the definition's Add row, and that row then travels as a SHELL: every nested <versions> block is removed from the definition document before the package is built, so the target creates the parent while the selected version rows create exactly the versions you checked and no others. The row's Message column says so — Sent as a shell without its N nested version(s); version rows in this package: <A>; K nested version(s) not in this package: <B>. (when the selected versions go in a later deployment of the same run — see Decision tables and the version that reads them — version rows, deployed after it: <A> instead) — N counts the nested <versions> blocks that were removed, A lists the deployable version rows of that definition you selected (capped at ten, ... and J more), and B lists, in document order, the names of the removed blocks whose <fullName> matched none of A plus any unnamed one (same cap); when K is zero the third part is left out, for example Sent as a shell without its 40 nested version(s); version rows in this package: Rev_Mgmt_Default_Pricing_Procedure_V440; 39 nested version(s) not in this package: Rev_Mgmt_Default_Pricing_Procedure_V10, Rev_Mgmt_Default_Pricing_Procedure_V20, Rev_Mgmt_Default_Pricing_Procedure_V30, Rev_Mgmt_Default_Pricing_Procedure_V40, Rev_Mgmt_Default_Pricing_Procedure_V50, Rev_Mgmt_Default_Pricing_Procedure_V60, Rev_Mgmt_Default_Pricing_Procedure_V70, Rev_Mgmt_Default_Pricing_Procedure_V80, Rev_Mgmt_Default_Pricing_Procedure_V90, Rev_Mgmt_Default_Pricing_Procedure_V100, ... and 29 more. The shell is built for an Add row and for an Update row whose version is in the same selection, only against an org target, and never for a row you edited by hand; an Update row's shell is sent so that the target keeps its own versions (its Message says Sent as a shell without its N nested version(s), so the target keeps its own versions; version rows in this package: <A>; …), because the whole document would write every version of the source into the target; a definition row (Add or Update) with no version row of its own still travels whole, which is what a Pricing Recipe's own cascade relies on — but an Update row leaves out, from the nested versions, the ones the target already has (an existing version is never changed), and names them on its row before the deploy and in the result: Version <A> already exists in the target and is not sent: an existing version is never changed — clone it in the source to deploy a change. (several: Versions <A>, <B> already exist in the target and are not sent: … — clone the one you want to change in the source and deploy the clone.). A definition row you edited in the diff view is sent as you edited it, so the nested versions the target already has are changed too, and the row says so (Edited in the diff view: sent as you edited it, so the nested versions the target already has (<A>) are changed too.). The versions the target does not have yet stay in the document; a git target is not affected. When the target already HAS the definition and its document differs from the source's outside the versions (its executionMode, for one), against an org target the definition's row is a dependency of its version row — ticked with it, removable — and goes as a shell without its nested versions, so the target keeps its own versions and a context the definition names reaches the table through it; its summary reads Its own properties differ from the target's (<the top-level tags that differ>): deployed with a selected version of it, it is sent as a shell without its nested versions, so the target keeps its own versions; selected without one, it is sent with the K of the source's N nested version(s) the target does not have yet (or as a shell, without its nested versions, when K is 0); edited in the diff view, it is sent as you edited it. (without the parentheses when the tags cannot be named, and without the part after the semicolon when the source document has no nested versions); when the definition switches its context definition, the summary adds The target's procedure switches its context definition from <A> to <B>; the target's own versions were built for <A>, and one of them switched on again later may not run or may be refused.; in Best Effort, when the definition row landed and none of its versions did, its result adds None of its versions landed (see their rows), but the definition's own properties did. (with a context switch: …did: the target's procedure now uses <B>, and its active version was built for <A> — deploy the version again or restore the definition in Setup.); against a git target, where there is no shell to send, the row stays in the table under its version row, visible and unselectable, with the reason This definition differs from the target's outside its versions (<the top-level tags that differ>); only versions are transferred, so change the definition itself in the target.; a difference in the versions alone produces no definition row. Two document elements an org below API 68.0 refuses are now removed by the plugin rather than by you: a procedure definition's root usageSubtype and a Pricing Recipe's root pricingUsageSubType, both with the value RevenueCloud, and both only when the comparison's Metadata API version is below 68.0 — the lowest version measured to accept the definition's tag (an org on 68.0 accepts a procedure definition's usageSubtype, an org on 67.0 refuses it, and the ExpressionSet.UsageSubtype picklist describe is identical in both orgs, so only the API version decides; a Pricing Recipe's own tag was measured refused on 67.0 and accepted once removed, and the same threshold is carried over to it). The row says which tag was left out and why: usageSubtype RevenueCloud left out: the comparison's API version 67.0 is below 68.0, the lowest measured to accept it. Any other value of either picklist is left alone, a nested tag of the same name is never touched, and against a repository target neither rule runs at all. In every deploy mode against an org target whose class the plugin has confirmed — non-production, or production with Deploy — the plugin reads the target's active version of the same procedure with one query before the package is built, for a version whose own document is Active; when the source version is Active and the target runs a different version as active, the document is sent with <status>Inactive</status> — the row's Message column says Status Active rewritten to Inactive: the target runs <version> as active. — and after that row succeeds the plugin activates it in the target itself: it deactivates the target's active version and activates the new one, two REST calls on ExpressionSetVersion, reported on the same row as Activated in the target; <old version> deactivated. A version that is not active in the source is never activated, a target with no active version receives the Active document unchanged (the platform activates it itself), and a version that already exists in the target is never changed (owner's decision of 27.10.2026; a definition document edited in the diff view is sent as you edited it; the version row itself cannot be unlocked by an edit): when its document equals the source's it is No change, and when it differs its row cannot be checked, whatever the status of either side, and says <version> already exists in the target, and an existing version is never changed: changes travel as a new version. Clone <version> in the source and deploy the clone. — Salesforce itself refuses a change to an active version with a misleading message about the Usage Subtype, and editing a version in the row difference view does not make the row selectable. A target that is a git repository has no such rule. The status is read from the target's answer, never guessed: when that query fails the document travels as it is and the message says so (Status left as it is: …); when the activation itself fails the row stays succeeded — the metadata did arrive — and the message names what was and was not activated (Activation failed: …); cancelling during the activation does the same — the row stays succeeded and its message says the activation was cancelled and what the target, read again, shows active — or that the target could not be read again (Activation cancelled…); the versions of the rows after it in the same deployment are then not activated, and each of those rows says Activation was not attempted: the operation was cancelled. When the new version could not be activated after the target's active version was deactivated, the plugin activates the previous version again with one more REST call, so the target keeps a working version, and the message says so: Activation failed: <new version> could not be activated (<reason>); <old version> was activated again. or Activation cancelled after <old version> was deactivated; <old version> was activated again.; when a call of the activation answers with an error — a refusal, a timeout, a cancellation — the procedure's versions are read again from the target before anything else is sent, because such an answer does not tell whether the call landed: an activating call that did land counts as done (… yet the target's versions, read again, show <new version> active.), the previous version is activated again only when the target shows no version active or could not be read, otherwise the message names the version the target shows active (the target's versions, read again, show <version> active; when that is the new version after a refusal, the message begins <new version> is active in the target or Activated in the target instead of Activation failed), and it sends you to Setup only when the target, read again, has no active version (when the target's versions were read again, no version of <procedure> was active — activate one in Setup., worded as an observation of that read, like the model's texts) or could not be read again (check in Setup which version of <procedure> is active.). When it is not known whether the old version was deactivated at all, the message says <old version> is active instead of was activated again. Validate only rewrites the document the same way but activates nothing — a Quick Deploy of that validation activates afterwards exactly as Deploy would, except that a validation of several deployments offers no Quick Deploy (its results screen says Quick Deploy is unavailable: this validation ran as several deployments, and Salesforce cannot quick-deploy a later one after an earlier one lands — deploy the selection instead.) — and a validation does not check the status rule at all, so a Validate only run can report Would succeed where the real deploy is refused. What the plugin leaves to you: a document element that the target's older release does not accept and that is not one of the two named above (remove it in the diff view before the deploy); a procedure definition you edited in the diff view for a procedure the target ALREADY has, which is sent with the nested versions the target already has and which the target refuses when it changes the version the target runs as active — and a copy from another org in practice does, carrying its own status and lookup ids — clone the version in the source and transfer the clone; the platform's cap on pricing elements per pricing procedure; waiting for a deployed context definition to finish compiling before deploying the procedure version that reads its new tags; and the data in the decision tables' source objects. The target resolves each lookup step's decision table by its API name, so the source org's record ids in LookUpId need no rewriting.

Decision tables and the version that reads them. A decision table the target runs as active refuses a changed definition (Can't edit an active Decision Table), so for a decision table Update row the plugin asks the target — with one query per deployment, in every deploy mode, against an org target whose class it has confirmed, about the org's own tables only (a table of an installed package is not asked about) — whether that table is Active there. A table you edited in the diff view keeps your edit: its status is not rewritten, and when the edited document keeps <status>Active</status> and the target runs the table active the row says Status left as it is: the document was edited in the diff view. The target runs this decision table active, and Salesforce refuses a changed definition of an active table unless the edited document sets <status>Inactive</status>.; when the edited document sets <status>Inactive</status> over a table the target runs active, the deployment deactivates it and the row says The table is inactive in the target after this deployment, as in the edited document. The review screen follows your edit too: an edited table's line says Inactive in the edited document: this deployment deactivates the table in the target. or, for an edited Active, that its status is left as it is. When it is and the source's is too, the table travels with <status>Inactive</status> (Status Active rewritten to Inactive: the table is active in the target.; the review screen already says Active in the target: deactivated for the deployment and activated again after it.), and once its row succeeded one REST call activates it again (Activated again in the target.); when that call fails the row names the table and the action (Activation failed: <table> could not be activated again (<reason>); it is inactive in the target — activate it in Setup → Decision Tables. …) and counts in Not activated: N. A source table that is not active over an active one travels as it is and the deployment deactivates it, which the review screen and the result row both say (Inactive in the source: this deployment deactivates the table in the target., The table is inactive in the target after this deployment, as in the source.); a new table activates itself. Salesforce can fail a deployment that changes several decision tables at once (it answered a package that changed Price_Book_Entry_Decision_Table_v2 together with another table with an internal null ,errorId on every table; one table per deployment passed, and which other pairs break was not measured), and accepts a pricing procedure version only while every decision table it reads is active — a table sent inactive in the same package does not count — so a selection with a table this deployment rewrites to inactive goes as several deployments when it has other rows (only then — never for a git target or a target whose class the plugin could not confirm): the first carries everything else; then each such table goes on its own, in name order, and right after it the plugin activates it again and waits until it is active, before the next one (the review screen adds Deploys on its own: Salesforce can fail a deployment that changes several decision tables at once., and its result row starts with Deployed on its own. — Sent on its own. when Salesforce did not accept it, Validated on its own. in Validate only); then the selected pricing recipes, when the selection carries a version (see The pricing recipe below); last, in the second package, the versions that read such a table, every other selected version of the same procedure, its definition row and any selected row that depends on them — all selected versions when a recipe went before them — each deployment with the same Apex tests. The review screen names every version of the second package on its own line, when the target's copy of the table is Active and the table's row is in the comparison: a version that reads the table gets Goes in a second package, after the decision tables it reads (<tables>) are active again: Salesforce refuses a procedure version while a decision table it reads is inactive. If Salesforce refuses the second package, the first one stays in the target., and a version of the same procedure that reads no such table itself gets Goes in a second package with <versions>, a version of the same procedure that reads a decision table this deployment switches off: the versions of one procedure deploy together. If Salesforce refuses the second package, the first one stays in the target. Each deployment is atomic or best-effort by itself, as the mode says: in Deploy the earlier deployments stay in the target when Salesforce refuses a later one, and in All or nothing (and against production) a refused deployment stops the ones after it — their rows say Not deployed: an earlier deployment of this run was refused (<row>)., naming the first row of the earliest refused deployment — while Best Effort sends every one. A row of the second package that Salesforce accepted starts with Deployed in a second package, after <tables>.; a row that was sent but not accepted starts with Sent in a second package, after <tables>. (the tables named are only those that landed in the first package; when none did, the prefix is just Deployed in a second package. or Sent in a second package.) When two or more deployments go before the versions (the first package and a decision table's own deployment, two decision tables, a table and a recipe), the versions are not the second package: their rows start with Deployed in the last deployment, after <tables>. or Sent in the last deployment, after <tables>. (just Deployed in the last deployment. or Sent in the last deployment. when no table landed in the first package), in Validate only with Validated in the last deployment: Quick Deploy is not offered for this validation, because Salesforce cannot quick-deploy a deployment that follows others — deploy the selection instead., and a deployment that got no answer reads The last deployment stopped before Salesforce answered (<reason>); … (The last validation stopped before Salesforce answered (<reason>); validate the selection again. in Validate only); the review screen does the same when the comparison has two decision tables this deployment switches off, or one of them and a recipe: Goes in the last deployment, after the decision tables it reads (<tables>) are active again: … If Salesforce refuses the last deployment, the earlier ones stay in the target. and Goes in the last deployment with <versions>, a version of the same procedure … (the review does not know whether the first package will be sent, so with a single table it keeps saying a second package). When a later deployment gets no answer — the CLI fails, or Cancel comes while it travels — its rows are Failed with This deployment stopped before Salesforce answered (<reason>); … (for the second package The second package stopped before Salesforce answered (<reason>); …, in Validate only The second validation stopped before Salesforce answered (<reason>); validate the selection again.; a decision table's own deployment adds If it arrives, <table> arrives inactive — activate it in Setup → Decision Tables.), the earlier deployments stay and the results screen appears. In All or nothing (and against production) a deployment that got no answer holds the ones after it too, with its own text — not the refusal one: Not deployed: an earlier deployment of this run stopped before Salesforce answered (<row>) — compare again before deploying <row> again. When a table that went on its own is still not active after its deployment, All or nothing — like production — sends nothing after it (Not deployed: <table> is not active in the target after its own deployment (see its row) — deploy <row> again once <table> is active.; when its status could not be read, Not deployed: the status of <table> could not be read after its own deployment (see its row) — deploy <row> again once <table> is active.), and the table's own row ends with It was still not active 90 seconds later, so the deployments after it were not sent (see their rows) — check it in Setup → Decision Tables. (or with Salesforce reported it as <status> after it was switched back on, … or Its status could not be read after it was switched back on (<reason>), … and the same ending), while Best Effort goes on and leaves out only the versions that read it (a table whose status could not be read holds nothing back there, and its row ends with Its status could not be read after it was switched back on (<reason>) — check it in Setup → Decision Tables.). A table of the first deployment the versions wait for — a new one, or one sent active over an inactive one — that is still not active by then holds back, in Best Effort, only the versions that read it and, in All or nothing and production, the whole second package; such a row says Not deployed: <table> is not active in the target after the first package (see its row) — deploy <version> again once it is active. (or, when the status could not be read, Not deployed: the status of <table> could not be read after the first package (<reason>) — deploy <version> again once it is active.). The table's own row, whose status stays as it was, then ends with It was still not active 90 seconds later, so the procedure versions that read it were not deployed (see their rows) — check it in Setup → Decision Tables. (or, when Salesforce reported another status straight away, Salesforce reported it as <status> after it was switched back on, so the procedure versions that read it were not deployed (see their rows) — check it in Setup → Decision Tables. — for a table the plugin did not switch on itself (a new one, or one that was not active) Salesforce reported it as <status> after this deployment, so the procedure versions that read it were not deployed (see their rows) — check it in Setup → Decision Tables.; or, when its status could not be read and the versions were held back, Its status could not be read before the second package (<reason>), so the procedure versions that read it were not deployed (see their rows) — check it in Setup → Decision Tables.), every such table gets its own note, not only the first, and a table the plugin had switched back on counts in Not activated: N as well — except one whose status could not be read, which nobody established as not active. No later deployment is sent when Cancel came between two of them (Not deployed: the operation was cancelled before this deployment.), while a table that already landed is still switched on again; the versions left out count in Not activated: N. A version of another procedure that reads no table this deployment switches off stays in the first package; when a table a version reads ends inactive, Salesforce refuses it, and the review screen says so in advance when the table's row is in the comparison (Reads <table>, which this deployment leaves inactive: Salesforce refuses a procedure version while a decision table it reads is inactive.). The tables are activated before any pricing procedure version, and a version is activated only when every table of the same deployment it reads is active — a table the deployment activated itself (also one it switched back on, before the second package is sent) is checked every 5 seconds for up to 90 seconds — otherwise it stays inactive with Activation skipped: <table> is not active in the target; <old version> is still active. The version is not activated either when Salesforce refused a table of this deployment that it reads (Best Effort keeps the rows it accepted): the target does not have the definition this deployment sent for that table, so the version row says Activation skipped: <table> was not deployed (see its row); <old version> is still active. (several refused tables are listed in one line, see their rows). When tables that version reads did land changed, the row goes on with <old version> still runs and reads the decision tables this deployment changed (<tables>) — deploy <refused tables> again, then activate <new version> in Setup. When the tables this deployment changed are in place and the new version was deployed but not activated, the old version keeps running against the changed tables, and the version's row ends with <old version> still runs and reads the decision tables this deployment changed (<tables>) — activate <new version> in Setup.; when the target, read again, has no active version at all, it ends with No version of <procedure> is active and the decision tables this deployment changed are in place — activate <new version> in Setup. instead, and when the target could not be read again it gets neither — its text already sends you to Setup. When the call that activates one table is answered by the channel with a cancellation, that table's row says so and the next tables are activated all the same. When Salesforce refuses the version row itself (whether or not the deployment was to activate it) but a decision table this deployment changed — one that version reads — landed, that row ends with The decision tables this deployment changed (<tables>) are in place while <new version> was not deployed — the active version of <procedure>, if any, reads them; deploy <new version> again once its refusal is resolved. Between the package landing and the new version's activation — seconds; when the selection goes as several deployments, for as long as the deployments after the first take (the wait for the tables it reads — up to 90 seconds each time they are not yet active — then their deployments and, against production, their Apex tests) — the old version already reads the changed tables: the plugin shortens that window but does not close it. Two refusals of a version row get a hint after Salesforce's own text (the first also on a refused expression set definition row, which carries its versions): Lookup API name: <table>, but LookUpId is null adds The target has no decision table <table>: select its row (Add) or deploy it first., and Specify a valid data type for the <name> variable adds A step of this version reads or writes a context tag the target's context definition does not have (step parameter <name>): deploy the context definition with that tag first and wait until the target compiles it. A version refused with Activate the <label> lookup table used in the expression set gets A decision table this version reads is inactive in the target (<label>): Salesforce accepts a procedure version only while the tables it reads are active — activate it in Setup → Decision Tables and deploy this version again., provided <label> is the label of a decision table that version reads and whose row is in the comparison; when it is the selection itself that leaves the table inactive (its source or your edit is Inactive), the hint instead says A decision table this version reads is inactive in this deployment (<label>): Salesforce accepts a procedure version only while the tables it reads are active — deploy <label> as Active, or deploy this version again after <label> is active in the target.

A decision table that loses an input column. Salesforce refuses to remove an input column of a decision table while an active procedure version in the target reads that table (null ,errorId … (499072613)), even when the table deploys on its own; the same change lands once the versions that read it are switched off. For a decision table Update row whose status the plugin rewrites from Active to Inactive for the deployment (see above) and whose document drops an input column of the target's copy, the comparison reads the target's active procedure versions — one query, and one retrieve of the versions outside a managed package — and the row says Removes the input column <C>: Salesforce refuses that while an active procedure version reads the table (<V…>). Deploying it switches those versions off for the table's deployment (about <N> seconds, and longer for each further version) and on again — you confirm that before the deployment starts. Clear the row to keep the column in the target. When the versions could not be read the row says Removes the input column <C>; readers not checked (<reason>): Salesforce refuses removing an input column while an active procedure version reads the table. Compare again to check them, or clear the row to keep the column in the target. (a table document that cannot be parsed says Could not tell which input columns this row removes; readers not checked (the table document could not be read): … the same way), and a row that drops an input column but is not switched off (its source is not Active, the target's class is not recognized, or you edited the document in the diff view) says Removes the input column <C>: Salesforce refuses that while an active procedure version reads the table; this row is deployed as it is. — when the target's class could not be determined it adds , because the class of the target org (production or sandbox) could not be determined, so no version is switched off for it. Compare again, or clear the row to keep the column in the target. With a row of the first kind selected, Deploy, Best Effort and Next first ask Switch off procedure versions? — each table, its columns, the versions, about how many seconds (about 15 seconds in a sandbox and about a minute in production, and longer for each further version), that the confirmation also covers a Re-Deploy from the results of this deployment and, in a production org, This is a production org: the procedures do not run on these versions meanwhile. Switch off and deploy goes on; Cancel sends nothing, and you can clear the row to keep the column. Validate asks nothing. The table then deploys on its own, without the Apex tests you selected (its package carries no Apex and the tests go with the other packages of the deployment, so they do not lengthen the window): the plugin switches the reading versions off, deploys the table, activates the table and ALWAYS switches the versions on again — after a refused table, a missing answer or a cancel too — and the row says Active versions reading it (<V…>) were switched off for this deployment for <S> seconds and switched on again. A cancel inside the window says Active versions reading it (<V…>) were switched off for <S> seconds and switched on again. (the deployment never started). A version that is no longer active is left alone (<V> was no longer active and was left as it is.). A version Salesforce refuses to switch off keeps the table back: Not deployed: <V> of <P> could not be switched off (<reason>) — deploy the table again, or deactivate <V> in App Launcher → the procedure's list (Pricing Procedures for a pricing procedure) → <P> → Expression Set Versions first, then activate it again after the deployment., naming any version already switched on again; in All or nothing and against production the deployments after it are held (Not deployed: switching off the versions that read <T> was refused, so the deployments after it were not sent (see its row).), in Best Effort they are sent. A version that could not be switched on again is the first sentence of the row — <V> of <P> is switched OFF in the target: switching it on again failed (<reason>). Activate it in App Launcher → the procedure's list (Pricing Procedures for a pricing procedure) → <P> → Expression Set Versions — <P> does not run on <V> until then. — a later table read by the same version does not try again and says <V> of <P> is still switched OFF: switching it on again failed after the deployment of <T> (see its row). — it counts in Not activated, and in a production org the record phases do not start. A version from a managed package is never switched off. Validate switches nothing: the row says Validated as it is: removing an input column needs the reading versions switched off, which a validation never does. — and when Salesforce refuses that validation with 499072613, as it does while an active version reads the table, the row is Failed and the sentence goes on …, which a validation never does, so Salesforce rejects this validation while an active version reads the table; a deployment with the switch-off confirmed gets past it. — and such a validation offers no Quick Deploy (Quick Deploy is unavailable: deploying <T> switches active procedure versions off for a while, which Quick Deploy cannot do — deploy the selection instead.). A table refused with 499072613 without the versions switched off gets Salesforce refuses removing the input column <C> while an active procedure version reads the table (<V…>): clear the row to keep the column, or deploy again and confirm switching the versions off. (without the last clause when confirming cannot help). A table refused with 499072613 although its window switched the versions off gets Salesforce still refuses the table: another active procedure version may read it[ (<V…> could not be read when comparing)]. Deactivate that version (App Launcher → the procedure's list (Pricing Procedures for a pricing procedure) → its procedure → Expression Set Versions) and deploy the table again, or clear the row to keep the column in the target. When the same deployment carries a new Active version of the same procedure, the plugin activates it after the table and switches the previous one off, as above; otherwise the previous version is active again, as before the deployment. A Re-Deploy of such a table inherits the confirmation you gave the deployment it repeats; when the session carries none (the first deployment was a Validate, or you never confirmed), a Re-Deploy that would switch versions off is refused before anything is sent — Re-Deploy does not switch active procedure versions off (<V…>): leave <T…> out of it, or start a new comparison and confirm switching them off before Deploy. — and the results and the session stay. When Salesforce's answer to a switch-off is lost (a timeout), the plugin re-reads the active versions: a version that turns out to be switched off, or whose state cannot be read, is switched on again with the others, and the row's reason says …; the version was switched off although Salesforce answered with an error when that re-read shows it switched off, and …; the answer was lost, so the version may have been switched off anyway when the re-read fails. Before it switches anything off, the plugin checks that Salesforce will switch each reading version on again — Salesforce refuses that when the version's start date is not later than the start date of the active version of its context (the version start date and time are later than the start date of the context definition used in the version; the active version itself is not checked, so nothing else would warn you). The check reads each version's start date and two more queries (the contexts of its procedure and the start dates of those contexts' active versions); a procedure row that names no context definition cannot be checked either, so its version is not switched off. A version whose start date is not strictly later, or whose check could not be run, keeps its table out of the window altogether — no version of it is switched off — and the row says Removes the input column <C>; Salesforce would not switch <V> of <P> on again after the deployment: its start date (<d1>) is not later than the start date of its context <X> (<d2>), so the plugin does not switch it off. To deploy the change, switch <V> off, move its start date later than <d2> and switch it on again in App Launcher → the procedure's list (Pricing Procedures for a pricing procedure) → <P> → Expression Set Versions → <V> — <P> does not run on <V> meanwhile. Then compare again; or clear the row to keep the column in the target. (or Removes the input column <C>; could not check that Salesforce would switch <V> of <P> on again after the deployment (<reason>), so the plugin does not switch it off. Compare again, or clear the row to keep the column in the target.; when several reading versions are refused, each is named with its own reason and the closing action is said once); both start dates are date-and-time values compared in UTC and shown with seconds, so the border is not rounded; a date without a time is not read and counts as «could not be checked»; the table asks no confirmation. A deployment holds such a table without a single call to the org (Not deployed: and the same text); in All or nothing and against production the deployments after it are held (Not deployed: the versions that read <T> cannot be switched off safely, so the deployments after it were not sent (see its row).), in Best Effort they are sent. The check is repeated right before the first switch-off, and a table that was refused at the comparison stays refused even if you have moved the date since — compare again. If Salesforce still refuses to switch a version on again over the date, the first sentence of the row says …, then activate it in … after Move the start date of <V> later than the start date of its context. The versions are switched on again by the running plugin: if you close or reload the IDE (VS Code) while such a table is being deployed — the window lasts seconds in a sandbox and about a minute in production — a version can stay switched off with no row to say so; check it in App Launcher → the procedure's list (Pricing Procedures for a pricing procedure) → <P> → Expression Set Versions and activate it.

The pricing recipe. Salesforce refuses a pricing procedure version that reads a decision table the target's pricing recipe does not map (Ensure that the lookup table in the <step> step is valid and try again.), and a recipe sent in the same deployment as that version does not help — one deployed before it does. So when the selection carries a procedure version, the selected Pricing Recipe rows deploy on their own, after the decision tables and before the versions (when a recipe names as its default pricing procedure a definition this deployment creates, that definition goes in the recipe's own deployment as an empty shell — Salesforce accepts the two together — and its versions follow; if none of them lands, the definition's row says Deployed as an empty shell together with <recipe>, which names it as the default pricing procedure; its versions were not deployed (see their rows) — deploy them again. and the recipe's row adds <recipe> now names <definition> as the target's default pricing procedure, which has no version in the target yet — deploy the versions of <definition> again (see their rows).; a shell whose recipe did not land says only Deployed as an empty shell; its versions were not deployed (see their rows) — deploy them again., and when the versions' deployment stopped before Salesforce answered, both rows say …; whether its versions landed is not known (see their rows) — compare again before deploying them again. instead; a shell whose own deployment was refused names its versions as version rows, not deployed (see their rows): …, and a definition whose document carries nested versions — an edit made in the diff view, say — travels whole there, its row saying Sent whole together with <recipe>, which names it as the default pricing procedure.); without a version a recipe travels with everything else. The comparison reads the target's copy of each recipe: a version that reads a table the source's recipe maps and the target's copy does not checks that recipe's row (an Update row, against an org target — for a recipe the target does not have the plugin selects no row and writes no Reads … line, and a refusal gets the hint below) — a visible, removable checkmark — and its review line says Reads <tables>, which the target's pricing recipe <recipe> does not map: Salesforce refuses this version until it does. If <recipe> stays selected, it deploys on its own before the procedure versions. A recipe that a version brought in this way carries only the new decision tables that the versions read: the other tables it maps are not selected for creation (a recipe you selected yourself brings all the new tables it maps), and a mapping to a table the deployment does not carry is left out of the document with the note below. Against an org, the review line of a recipe says If a procedure version stays selected with it, deploys in a deployment of its own before the procedure versions: Salesforce checks a procedure version against the pricing recipe the target already has. If Salesforce refuses a later deployment, this one stays in the target., and a selected version without such a line says If the pricing recipe <recipe> stays selected, this version goes in a later deployment, after the recipe's own; if Salesforce refuses that later deployment, the earlier ones stay in the target. A recipe whose default pricing procedure differs from the target's copy says so on its review line: Deploying it also makes <procedure> the target's default pricing procedure (now <current>)., or (the target names none now) at the end when the target's copy names none. A recipe's deployment adds mappings and never removes one the target has. Before a recipe row is deployed to an org, the plugin asks the target — one query — which of the decision tables it maps exist there, and for the names that are not decision tables, in a second query, whether they are decision matrices (a mapping may name either): a mapping to a table or matrix the target does not have and this deployment does not create is left out of the document (Mapping of <table> left out: the target has no decision table or decision matrix <table>, and this deployment does not create it.), and when either query fails the document goes as it is (Mappings not checked: the target's decision tables could not be read (<reason>).); a recipe you edited in the diff view is never trimmed. A version refused for an unmapped table gets Salesforce refuses a procedure version that reads a decision table the target's pricing recipe does not map (<tables>): select the PricingRecipe row <recipe> or map the tables in Setup → Salesforce Pricing Setup, then deploy again. when the comparison knows which tables are missing — or, when the recipe row was selected and its deployment was refused in this run, Salesforce refuses a procedure version that reads a decision table the target's pricing recipe does not map (<tables>): the pricing recipe <recipe> was refused in this run (see its row) — fix the cause on that row, then deploy again. — or, when the recipe row was selected and its deployment landed, one of two texts by what that deployment did with the mapping: Salesforce refuses a procedure version that reads a decision table the target's pricing recipe does not map (<tables>): the pricing recipe <recipe> was deployed without the mapping of <tables> because the target has no such decision table (see its row) — deploy <tables> (select its DecisionTable row), then deploy again. when the mapping was left out, and Salesforce refuses a procedure version that reads a decision table (<tables>): the pricing recipe <recipe> was deployed with the mapping of <tables> in this run (see its row), so check in Setup → Salesforce Pricing Setup which pricing recipe the target runs. when the recipe went with it. In Validate only a version that reads a table only the selected recipe maps is not validated — Salesforce checks it against the recipe the target already has — and its row says Not validated: Salesforce checks a procedure version against the pricing recipe the target already has, and <table> is mapped only by <recipe> in this selection — deploy the selection to check it., and a mapping to a decision table only this selection creates is left out of the validated recipe (Mapping of <table> left out of this validation: the table does not exist in the target until this selection is deployed; the deployment carries it.). In Validate only a recipe that names as its default pricing procedure a definition this selection creates together with a version of it is validated together with that definition and its versions, not on its own, and the definition's row names only the versions that validation checks. A validation that goes as one deployment reads like one package and offers Quick Deploy, unless it left rows out (Quick Deploy is unavailable: this validation left out rows it could not check (see their rows) — deploy the selection instead.).

After a context definition row succeeded, the plugin reads the target's context service — one REST read, repeated every 15 seconds for up to two minutes — and when the tags that row added do not appear there, the row says Deployed, but <target>'s context service does not show <N> of its tags (<tags>) — add them in Setup → Context Definitions → <context>; procedure versions that use them are refused until then. That sentence is only said when the two minutes ran out; when the read itself fails, or Cancel interrupts the wait, the row says Context tags of the target could not be checked (<reason>). (cancelled after a Cancel) instead — the plugin does not call an unfinished check a verdict.

Permission Transfer Modes

The mode is chosen in the settings (see Settings and Session Log), not on the review screen, and it applies to every deployment until you change it.

The Select Permission Containers screen listing profiles and permission sets with Container, Label and Presence columns

The transfer covers six kinds of permission, and which of them a deployment touches is decided by the rows you check in the comparison table: a custom field row transfers its field-level security, a custom object or platform event row transfers the seven object permissions of that object — create, read, edit, delete, View All Records, View All Fields and Modify All Records — an Apex class row transfers access to that class, a Visualforce page row transfers access to that page, a custom tab row transfers that tab's visibility, and a record type row transfers whether that record type is visible. Nothing else is transferred — user permissions, application visibilities, custom permissions, licenses and layout assignments are left exactly as the target has them. A standard object's own CRUD is transferred through a Permissions only row, and so is the field-level security of managed and standard fields — see Rows that carry permissions but no metadata below.

Two boundaries are worth naming before you rely on the last two kinds. The default record type of the target is never changed by a transfer. Only visibility travels; <default> and <personAccountDefault> are read from the target document and written back verbatim, in every mode, so a transfer can neither set nor clear which record type an object defaults to. When the target's own record type is already the container's default and the source wants it hidden, nothing travels either: against an org target that row is Skipped with a message naming the default, and the target node is left untouched. And tabs of both kinds are transferred: a custom tab travels as its own metadata component, while a standard tab such as standard-Account travels as a Permissions only row whose name is the permission entry itself. Tab and record type rows are visible only when the UI & Navigation and Objects & Fields metadata categories are enabled in the settings; with the default settings they do not appear at all.

Rows that carry permissions but no metadata

A permission is an administrator's own configuration, not the property of a managed package or of the platform — so the comparison table lists managed and standard components too, and checking one of those rows transfers its permissions without transferring the component. Such a row spells out what it will do in the Diff column (IntelliJ) or the Details column (VS Code):

  • Permissions only — nothing at all is deployed for this row. Managed Apex classes, Visualforce pages, tabs and record types, managed and standard fields, managed objects, standard objects and standard tabs all get this. The row exists so that its permission can be selected; none of its metadata is deployed, so double-clicking it opens no comparison window. A managed or standard field reports No change even when the two orgs differ in its label — different package versions — or in its history tracking, because neither is something the plugin can or should move.
  • A row without that label deploys its document exactly as it always has.

Standard tabs are listed from the org's own tab definitions rather than from the metadata listing, which does not carry them, and their name is the permission entry itself (standard-Account). Standard fields of an object appear once that object is selected on the first screen; a field of an object you did not select never produces a row.

Against a non-production org, records deploy in Best-effort only: a checked Product Bundle row removes the Validate and Deploy buttons, and the core refuses those two modes on every entry of the deploy chain even if a patched client sends them. Against a production org, records are transferred as phase 2 of Deploy, after the metadata deployment succeeded, and Best Effort is never offered there. Records never reach a target whose class the plugin could not determine. The transfer never deletes a record in the target and never creates a product relationship type, a selling model or a price book.

Two boundaries stay in force and are worth stating plainly. The DEFINITION of a managed or standard component is still never deployed — no object definition, no field definition, no class body — and no such row can be edited in the diff view. The one narrow crossing is a Lightning page assignment in the element mode: the selected assignments are spliced into a fresh copy of the target's own standard app or standard object document, which otherwise stays exactly as the target has it, apart from assignments the target repeats byte for byte, sent once. And the history tracking settings of a custom field never travel: Track History and Track Feed History are each org's own decision, bounded by a per-object cap on tracked fields, so a deployed custom field keeps the target's own two toggles when the target already has the field and is created with both off when it is new. When the source's toggle differs, the row's result says so whether it succeeded or not — for example Not transferred: Track History — the target keeps its own setting (Track History off in the target, on in the source). — and you turn tracking on in the target's Setup if you need it there. The target's toggles come from the copy of the field the comparison read; if that copy cannot be read, the row fails with The target's copy of field '<Object.Field>' could not be read to keep its history tracking settings: … Compare again, then deploy., and in Validate only and All or nothing the whole deployment stops before anything is sent. A document you edited in the diff view is sent exactly as you wrote it, toggles included — a toggle your edit changes in the target is named on the row's result when the target's copy can be read (Sent as edited: …) — so Salesforce can still refuse its tracking for that one component: enabling Track History on a field of an object whose target org has history tracking switched off is refused with the org's own words — The entity: Account does not have history tracking enabled — and the per-object cap on tracked fields is reported as exceeded the allowed number of fields to track on a given entity. Both are single-component rejections and neither stops the rest of a Best-effort deployment; the fix is on the target and it is manual: switch history (or feed) tracking on for that object in the target's Setup, or remove the toggle from your edit, then deploy the row again.

The history and feed tracking settings of a custom object never travel either: Enable History, Enable Feeds, Record Type Track History, Record Type Track Feed History and its name field's Track History and Track Feed History stay as the target has them when the target already has the object, a new custom object is created with all of them off, and a differing source value is named on the row's result the same way — for example Not transferred: Enable History — the target keeps its own setting (Enable History off in the target, on in the source). They are not a difference in the comparison table either. The target's settings come from the copy of the object the comparison read; if that copy cannot be read, the row fails with The target's copy of object '<Name>' could not be read to keep its history and feed tracking settings: … Compare again, then deploy., and an object document you edited is sent as you wrote it, exactly like a field's. Because of this, a Lightning page that shows the object's history related list, or a feed-based page layout, can be refused by a target where that object's history or feed tracking is off — Could not find related list [Histories] for entity [<Object>] or feedLayout is not supported for this layout. The page or layout is still sent as it is; its row's result then adds the cause and the action: turn on Track Field History (or Feed Tracking) for that object in the target's Setup, then check the row on the results screen and press Re-Deploy. The action follows the object's own row in the same deployment (in Validate only nothing changes in the target, so every custom object row of that deployment counts as one the target did not accept, whatever its result): when that row was an Add the target did not accept, the object does not exist there, so the hint says to deploy the object without the page first, turn the setting on, then compare again and deploy the page; when it was an Update the target did not accept, it says to turn the setting on and compare again first, because deploying the object row alone would send the copy of the target read at Compare, with the setting still off.

The Permissions transfer setting offers three choices:

  • Do not transfer permissions deploys selected metadata without retrieving or changing any permission.
  • Additive permissions is the default. It transfers source access for the selected rows without revoking existing target access. Every flag is merged independently with OR semantics, so the result is the union of normalized source and target access.
  • All permissions fully synchronizes each selected eligible row to normalized source access in every matched container, so it can grant or revoke access.

Additive permissions and All permissions include selected No change rows immediately and selected Add or Update rows only after their metadata deployment result is Succeeded. A selection containing only No change rows skips component deployment entirely. The plugin matches source and target standalone Permission Sets by metadata full name and Profiles by metadata full name. That full name is the API name of the metadata document, which for many standard profiles is not the label Setup shows you: the profile labelled Standard User is Standard, System Administrator is Admin, and a profile whose label contains : or . carries a percent-encoded full name such as Custom%3A Marketing Profile. Both names are shown — the full name in the Container column and the label in a Label column — and only the full name is ever used to match, retrieve, package and merge; the label shown is the target org's for a matched container and the source org's for a newly creatable Permission Set, so it is always the label you would find by opening Setup on the org that ends up holding the permissions. Namespaced permission containers are excluded, and so is a Permission Set Group: a group is a metadata component of its own — comparable and deployable since the Security & Sharing types were added — but it is never a permission container, because permissions live in the sets it lists rather than in the group. This is also why standard profiles now appear on the container-selection screen at all: matching them required resolving the profile's full name, which a Setup-facing profile display name alone did not give. They list as Existing containers exactly like any custom Profile, and — like every selectable container — start checked, so an All permissions run writes into a standard profile unless you deselect it first.

Choosing Additive permissions or All permissions and Next opens a container-selection screen listing every eligible container: Existing containers matched by kind and API name in both orgs, and New Permission Sets that exist only in the source and are eligible for creation. When none of the checked rows carries a permission subject — a field, an object, an Apex class, a Visualforce page, a tab or a record type — that screen is skipped: the review (or Apex test) screen is then the last one and shows the deploy mode buttons directly, and the deployment produces no permission result rows, because there is nothing to transfer. Each row shows its metadata full name in the Container column, its label in a Label column, and its presence in an Existing/New column; the label and the full name each have their own substring filter, and the presence is filtered with the Presence column's multi-select, which shows both values by default. The permission result table carries the same Container and Label pair, in that order. Select All and Clear apply only to the currently visible, filtered containers. Every selectable row starts checked — every Existing container and every New Permission Set; a New Profile is listed for information only, with its checkbox disabled, because the permission transfer never creates a Profile. Deselect any selectable container to exclude it from this deployment. A Permission Set or a Profile you checked as a row of the comparison table is not offered for selection here: its whole document is being deployed as metadata — replacing that container for a Permission Set, merging into it for a Profile — and letting the permission transfer write the same file in the same deployment would mean two authors of one document. The exclusion is decided by the pair of kind and name, so a Permission Set and a Profile that happen to share a name never exclude each other. The core itself drops that container from the deployment before it is sent, independent of what the client displayed or selected, so no client mistake can produce two authors of one file. Such a container stays on the list with its checkbox disabled, exactly as a source-only Profile does, so you can see it was excluded rather than wonder where it went, and — since the release that copies a created set's license — it names its reason: hover the checkbox and every disabled row tells you why, a container deployed as metadata by its own comparison row, a Profile the permission transfer never creates, or a New Permission Set whose license the target org does not have. A container that is left unselected is reported Skipped with "Not selected for permission transfer."; this is an additional, user-driven Skipped reason alongside target-only, namespaced, and other ineligible exclusions, and it does not change any other result semantics. A container the user did not choose is never reported Failed: an ambiguous duplicate identity, hidden from this screen because it cannot be individually selected, still reports Skipped with its own "Ambiguous source/target permission container API name." reason rather than a false Failed, exactly as any other unselected, ineligible container keeps its own reason.

The plugin retrieves both copies of each matched Permission Set/Profile and uses the target XML as the merge base. The retrieve manifest names every selected subject explicitly — the fields, the objects, the Apex classes, the Visualforce pages, the custom tabs and the record types — so a target Profile comes back with its real permissions instead of Salesforce filtering it down to empty lists. All selected rows for that container are accumulated into one metadata document. Only their own fieldPermissions, objectPermissions, classAccesses, pageAccesses, tab and recordTypeVisibilities entries are merged according to the selected mode; unrelated target entries of those same kinds, and every other target metadata node, remain intact byte for byte. A Permission Set spells tab visibility as tabSettings with Visible/Available/None while a Profile spells it as tabVisibilities with DefaultOn/DefaultOff/Hidden; the plugin reads and writes each container in its own vocabulary and shows you one normalized value. Against an org target, if a tab carries a visibility value this version does not recognize, that row is Skipped with the value quoted in its message and the target entry is left untouched; against a git target merge_container_documents keeps only the merged document and discards the reasons channel, so neither this nor the default-record-type outcome produces a result row there. Edit access implies read access, formula fields are normalized to editable=false, and required fields are skipped because Salesforce does not support field-level security for them.

In Additive permissions, an absent or narrower source entry never removes or reduces target access. In All permissions, an absent source entry means no access at all, so synchronization removes the corresponding target entry — with one deliberate exception for the two kinds whose "no access" the org spells out explicitly. For a tab or a record type, an existing target entry is kept and rewritten to the explicit no-access value (None in a Permission Set, Hidden in a Profile, visible=false for a record type) instead of being removed, because removing the entry would leave the target untouched rather than narrowed: a deploy does not change what the document does not mention. So a tab hidden in the source does become hidden in the target, and the entry stays visible in the deployed document. If the target has no such entry at all, there is nothing to narrow and none is created. Target-only containers are Skipped; the plugin never deletes a target-only container. A source-only Profile is also Skipped, because the permission transfer never creates a Profile. A source-only, non-namespaced Permission Set is classified New; when selected, the plugin may create a Permission Set in the target when it is missing there, populated with only the selected rows' permissions — the field-level security, object CRUD, Apex class access, Visualforce page access, tab visibility and record type visibility you checked — plus exactly two descriptive tags copied from the source document, its <description> and its <license>, and nothing else: never a user permission, never an application visibility, and never a Profile. A tag the source does not carry is not invented, and an empty <description> travels empty — but an empty <license> is dropped instead of copied, because the target rejects the whole container over it exactly as over a license it does not have. The license is copied because it is part of what the source set is, and it has to be one the target org already has: a license the target org does not have makes Salesforce reject the whole container, so not one of its permissions would land. That is why such a container is not offered at all — a New Permission Set whose license is in neither the target's Permission Set Licenses nor its User Licenses is listed with its checkbox disabled and the reason on the row, and it is refused a second time in the core, right before the container is built, in case the org changed between the screen and the deployment, where it is reported Skipped with the same reason. If the target's licenses cannot be listed at all, the same rows are disabled with the listing's own sanitized reason rather than sent blind. Against a git target nothing is disabled: a branch carries no licenses, so there is nothing to check against. Profiles that do not exist in the target are not created by the permission transfer; a custom Profile can still be created by its own checked comparison row, which deploys that profile as metadata and is visible in the table before the deploy. A selected row whose desired access already matches the target is also Skipped because it requires no deployment.

All permissions can make destructive changes (access revocations) only for a unique, non-namespaced source-and-target container match by both kind and API name. Target-only, namespaced or otherwise ineligible, required-field, and no-op outcomes are Skipped; a source-only Profile is also Skipped, but a selected source-only, non-namespaced Permission Set is instead created in the target and reported Updated. Ambiguous duplicate container identities and Salesforce deployment rejections are Failed, but ambiguity yields Failed only for a container the user actually selected on the container-selection screen; an ambiguous duplicate the user did not choose is Skipped with the same "Ambiguous source/target permission container API name." reason instead, because nothing was attempted for it. In the permission results table, the Status column filter hides Skipped rows by default; check Skipped in that column's filter to reveal them.

Changed Permission Sets and Profiles are first submitted together in one aggregate Metadata API deployment. A component-specific failure causes recursive splitting by container until the failing Permission Set/Profile is isolated; the plugin never splits one container's accumulated field changes into per-field deployments. A container is reported successful only after a deployment containing that component succeeds. Fatal authentication, authorization, CLI, network, workspace, cancellation, or response errors stop further scheduling. Updated means an actual permission-metadata change was deployed; no-op rows are Skipped. There is no rollback across separate successful fallback deployments.

Before any of that scheduling starts, the plugin has to read the Permission Set/Profile catalog itself — the SOQL query that lists candidate containers and the metadata inventory that tells, from that same response, both which of them can actually be retrieved and, for the ones the org's metadata Id resolves, their own metadata fullName (the container's identity). Each of those two read-only calls is retried once on a failed CLI response; a cancellation is never retried, and it still stops the whole operation like any other cancellation. In Best-effort mode against an org target, if that early catalog read still fails after the retry, the permission step does not take the metadata report down with it: every component of the package above keeps its own result row, and every permission/container pair that would have gone through it is instead reported Not Attempted, with the sanitized failure message available in Show Details. In Validate only and All or nothing, and against a git target, the same catalog failure stops the whole operation before anything is deployed or committed.

The permission result table's column filters do not change the counters. The Status column filter defaults to Updated, Failed, and Not Attempted checked and Skipped unchecked; check Skipped to include it, or uncheck any of the other three statuses to narrow the view further.

Safety Boundaries

  • Salesforce authentication stays in the local Salesforce CLI: the plugin never implements OAuth, never asks for credentials, never persists a token. Under the default Read orgs through value, Salesforce CLI (sf), every read of an org runs sf; with Salesforce API (faster), for its direct calls to the Salesforce APIs — every read of an org, and the REST record writes of a Product Bundle or Constraint Model transfer — it uses, in memory only and for the lifetime of the core process, the access token the CLI itself reveals for an alias; the token never reaches a log, a diagnostic, a copy, the session export or the disk, and a refresh is always the CLI's own. The plugin never asks the user for access tokens, refresh tokens, passwords or auth URLs and never displays them.
  • CLI commands are executed directly as argument lists, not through a shell. Diagnostics are sanitized before display or copy.
  • Opening an org in the browser — the icon left of + in an org row and the Deployment Status link of a deployment into an org — runs only the Salesforce CLI's own sf org open, for an alias the core itself listed or the target of the running deployment, with a path the core chooses from a fixed set; its output is never read, logged or returned — on success it carries a login URL with a session token — and a failure shows only the sanitized diagnostic.
  • Namespaced metadata is never DEPLOYED as metadata, and that is a statement about the deploy, not about the table: a namespaced field, object, Apex class, Visualforce page, tab or record type does get a comparison row, because a row is how its permission is selected, but its own definition is never compared or deployed. Ordinary custom names such as Field__c remain eligible for a full metadata deployment. A Permission Set or a Profile row deploys its whole document, exactly like any other component; the container-selection screen is a separate path for permission synchronization, and the two never write the same document twice because checking a container's comparison row makes that same container unselectable on the container screen. A namespaced object's own definition is excluded the same way — never compared, never deployed — but the object itself is listed and selectable, because it is the only gate through which its unmanaged fields and other unmanaged children can be selected, and through which its own CRUD can be selected too.
  • An object is created in the target only when its CustomObject Add row is checked in the comparison table — either by you or automatically as a visible dependency of a component you checked; the auto-check can be removed, and the object creation is always visible in the table before the deployment. Target-only fields are never deleted, and standard-object metadata is never deployed as metadata: the standard object's own definition is never sent, and neither is a standard field's definition. The history tracking settings of a custom field do not travel either: a deployed custom field keeps the target's own trackHistory and trackFeedHistory, or is created with both off, and a differing source value is named on the row's result. The same holds for a custom object's history and feed tracking settings (enableHistory, enableFeeds, recordTypeTrackHistory, recordTypeTrackFeedHistory, and its name field's two toggles): a deployed custom object keeps the target's own, or is created with them off. Page Layouts and the types stored inside an object's folder (list views, record types, validation rules, field sets, compact layouts, business processes, indexes, sharing reasons, web links) are the deliberate exceptions — those of a standard object are compared and deployed, because they are the admin's own configuration rather than the object definition.
  • Deploying one child of a container document — an assignment rule, an auto-response rule, an escalation rule, a sharing rule or a custom label — never removes the other children of the same container. The package carries only the children you selected, and the Metadata API leaves the rest in place; against a git target the plugin merges the selected children into the branch's own copy of that file, so a rule or a label that exists only in the repository survives the deployment.
  • What a deployment may remove from a document depends on the mode of the document — its Elements checkbox on the selection screen — and in both modes it is visible in the table before you deploy. In the default whole-document mode a page layout, Lightning page or report type deployment replaces the target document with the source document, so elements that exist only in the target are gone afterwards — the same Metadata API semantics as for a bundle. In the element mode nothing is replaced wholesale except the one element a selected Update row names: a related-list Update row overwrites that list's columns, sort field, sort order and buttons, so anything present only in the target's copy of the same list is gone after the deployment, and that related list is the only place where the element mode removes content from a layout; a report type column Update row replaces that one column; a Lightning page Update row replaces that element's own properties and visibility rule, so a property or a visibility rule the source element does not have is gone after the deployment; and a Lightning page Add row that carries Dynamic Forms, when the source page has no Record Detail of its own, removes the target page's Record Detail component (force:detailPanel), which the row names in its differences before you deploy — the only component the element mode removes from a page: the content of the target page's facets, its other components and its fields are never removed. A Lightning page assignment row never removes an assignment of the target: an Update row replaces exactly the assignments on its own key, each named in the row's differences before you deploy; the one exception is an assignment the target's app or object document repeats byte for byte, which the deployment sends once and the row names before you deploy (what Salesforce then keeps for the second of two profiles sharing one name is not measured yet). Everything the merge did not touch is preserved by construction, and elements that exist only in the target are never removed. A Context Definition in the element mode removes nothing: the selected new elements are inserted into a fresh copy of the target's definition and nothing in it is changed or removed; what Salesforce's own sync of a definition behind the source's release adds, changes and removes is shown on the row before you deploy, in both modes. In neither mode is a target-only document touched: a document that is missing from the source produces no row at all.
  • Deploying a flow creates a new version in the target and never deletes or deactivates an existing version. The target's active version is replaced exactly when the source flow's <status> is Active, because the status is transferred verbatim and is visible in the comparison row before the deployment — except for a row whose document was edited, marked Edited, where the status that deploys is the one in the edited document rather than the one the row shows.
  • An edited document is the sole case where the deployment sends content that exists in neither the source nor the target org — it is an edited increment stored in the comparison's temporary workspace. The edit is visible and removable before the deployment, stored and destroyed with the session, and never widens what the deployment would send (it does not select an unselected row or remove any safety boundaries). It removes exactly one: an object created from an edited row is created from that edited document rather than from the minimal synthesized one, for that row and that comparison only.
  • Optional permission synchronization is limited to selected metadata-identical rows plus selected rows whose metadata deployment succeeded. For an Existing container it merges only those rows' own fieldPermissions, objectPermissions, classAccesses, pageAccesses, tab and recordTypeVisibilities entries into target-based Permission Set/Profile metadata, and only for the containers the user selected on the container-selection screen; deselected containers remain untouched and are reported Skipped. The plugin may create a Permission Set in the target when it is missing there, populated with only the selected rows' permissions plus the source document's own <description> and <license> — never a user permission, never an application visibility, and never a Profile; a container whose license the target org does not have is shown unselectable with that reason instead of being deployed. Profiles that do not exist in the target are not created by the permission transfer; a custom Profile can still be created by its own checked comparison row, which deploys that profile as metadata and is visible in the table before the deploy. The default record type of the target is never changed by a transfer, and tabs of both kinds are transferred: a custom tab as its own metadata component, a standard tab as a Permissions only row.
  • The IntelliJ system directory is the explicit local filesystem trust boundary. The plugin parent is its direct child orgbench; operation workspaces below it contain no credentials. On Windows the plugin parent and descendants are created with owner-only ACLs. Workspaces are closed after handled failure, cancellation, Back, New Comparison, or project disposal; after a successful deployment the workspace stays open while the results screen is shown — Re-Deploy sends from it — and closes when you leave that screen. If cleanup fails, the error is surfaced and the owned workspace is retained for another cleanup attempt on reload or close.
  • Manifest export and import (package.xml) still live in the plugin core with the same guarantees as before — Session Export is the more capable, supported way to reach the same round trip today, so neither client's UI exposes a manifest button any more. When exercised, import changes only the local selection: it never touches either org beyond the standard source-org component listings, namespaced members are never imported — a managed-package object member is not one, it imports as its unmanaged fields and never as an object definition — and it rejects a DOCTYPE declaration or a file larger than 5 MB outright; a standard object's imported fields also derive that object's own CustomObject manifest member — the same derivation a live selection performs — so the import summary carries both, even though the object's own definition can never be deployed and the derived member resolves to nothing more than a Permissions only row; any failure leaves the previous session manifest in place.
  • Importing a session scenario only changes local selections, never a live org or repository beyond the source-org component listings a restored manifest is checked against. A rejected endpoint, an unmatched manifest member, or an unmatched comparison or container row leaves the prior manifest and prior endpoints exactly as they were and is reported instead of guessed at. The absolute path of a git repository never reaches the scenario file, so a git endpoint can never be restored from one — it is left untouched, with a warning, same as any other unmatched name.
  • Every deploy mode sends the whole metadata selection as one Metadata API deployment — except a selection with a decision table the deployment switches off next to other rows, or with a pricing recipe next to a procedure version, which goes as several deployments (in the Deploy modes the earlier ones stay when a later one is refused or gets no answer, and the review screen says so), and except the narrow retry paths in Best-effort against an org target, described above: one Permission Set Group retry call, at most three Context Definition retry calls, at most three Permission Set retry calls in TRIM_AND_RETRY, the default — at most four in TARGET_CONFIRMED, none in OFF — at most five Profile retry calls, and one generic-error retry call carrying only the rows whose failure is the target's generic error and, when the whole-set retry sent more than one row, one lone call per still-generic row; separate successful permission fallback deployments are not rolled back when later work fails. Always review both result tables before treating an operation as complete.
  • Active procedure versions of the target are switched off only for the deployment of a decision table that removes an input column they read, only after you confirmed it, only when Salesforce will switch it on again (the version's start date is later than the start date of its context), never by Validate, never a version from a managed package, and switched on again afterwards by the running plugin (closing or reloading the IDE (VS Code) during those seconds can leave one off — see above).
  • Preparing the orgs is the only operation that changes the SOURCE org. It writes only the external-key value on each object — its own OrgbenchExternalId__c field, or an already-existing CUSTOM external-ID field BOTH orgs carry for that object, when one is found — a standard field flagged externalId is never accepted — plus field-level access to a newly created field on the running user's profile in both orgs; no other data changes and no record is ever deleted. It runs as a separate command behind an explicit confirmation that names both orgs, and is never part of a deployment. A record that already carries the key is not changed, so running the command again changes nothing. The button that starts it appears whenever an enabled metadata category holds records rather than metadata files, and it changes shape by itself: while the orgs still need an external-key field it reads Prepare Orgs, and once both orgs already carry every key the command would create it shrinks to a refresh icon (a ↻ glyph in VS Code). The check behind that shape only reads both orgs and never writes; when it cannot be answered the button simply keeps its text.
  • Check target on the selection screen reads the target org and nothing else: it sends no write and no delete, needs no source, and is not part of a deployment. Its findings are never fixable, and the broken-reference findings the Deploy check adds change no decision of that deploy.
  • Describe differences with Claude Code is the only path that hands org content to a program other than the Salesforce CLI and git, and only when you choose it: the setting is off by default, and while it is off no row offers the item and nothing is read, started or sent. Chosen, it sends the two versions of that one Flow, Apex class or Apex trigger, exactly as the diff view shows them, through the standard input of your own local claude -p with a fixed set of options that switch its tools off; Claude Code sends them to the model provider it is set up for (Anthropic by default), under your own account and settings with that provider, which the plugin never reads. Aliases, repository names and paths, branch names and tokens never enter the prompt, and neither the prompt nor the answer reaches the session log, the session export, a diagnostic copy or a file the plugin writes; the answer lives only in the comparison screen and its read-only tab. Nothing in any org or repository changes, and Cancel keeps the comparison open.
  • Automated tests use fixtures and fakes; the default Gradle test task does not connect to a Salesforce org.
  • Automated orchestration tests cover the single-package Best Effort path (--ignore-errors, per-row isolation of a component that cannot even be packaged), aggregate permission deployment, container-level permission fallback, fatal stop, and Not Attempted ordering. The manual guide deliberately validates one real field component failure without intentionally causing an authentication or network failure against a live org.

All four tables — object selection, component review, permission container selection, and both result tables — share one filterable layout: a header row, an aligned per-column filter row beneath it, and the data. Column widths are saved globally per table in IntelliJ application properties after a header resize; the compact default sizes any Select column to its actual checkbox header, keeps narrow columns like Change and Status compact, and leaves the widest text column (Diff, Message) expanding. The filter row re-aligns each filter cell to its column as columns are resized. Saved table widths apply across projects and IDE restarts and are clamped to safe minimums when restored.

Licensing

Orgbench is free during early access. A paid tier for advanced features is planned; nothing is gated today, and every feature described above is available to everyone.

  • The license path is fully offline. Validation is a local signature check inside the plugin's own core — there is no license server, no phone-home, and no network call of any kind, not even a revocation check. The promise that your metadata never leaves your machine covers licensing too — and it holds unless you turn on Describe differences with Claude Code, which hands two versions of one component to your own Claude Code.
  • Any licensing failure degrades to the free tier and keeps working. A missing key, a key damaged by copy-paste, a key signed by someone else, an expired subscription, a strange system clock, and an unreadable state file each land on the free tier without an error dialog and without the plugin refusing to run. A write that fails while you are entering a key does not stay silent, including when the cause is a data directory the plugin could not reach or create: the status line names the reason, and the tier stays free because the key genuinely was not saved.
  • Safety is never gated. Every boundary listed under Safety Boundaries applies in every tier, forever.
  • The key and the first-run timestamp live in a single file the core owns, inside your user data directory — ~/Library/Application Support/orgbench/ on macOS, %APPDATA%\orgbench\ on Windows, $XDG_DATA_HOME/orgbench/ or ~/.local/share/orgbench/ on Linux. Enter a key once in either editor and it applies in both, once each editor's own core has (re)started and read the file; the editors themselves store nothing, and the file never leaves your machine.
  • Enter or remove a key under Settings | Tools | Orgbench in IntelliJ, or with the Orgbench: Manage License command in VS Code (the key icon in the view title opens it). IntelliJ shows a read-only status line with what the core decided; VS Code shows the same status as the title of that command's own picker — either way, the reason a key was not accepted is shown, not just the tier.

Build

Use a JDK 17 runtime and the checked-in Gradle wrapper:

./gradlew test
./gradlew verifyPlugin
./gradlew buildPlugin

./gradlew buildPlugin also compiles the Rust core (sf-core-server) for macOS arm64, macOS x64, Windows x64 and Linux x64 and bundles all four under bin/ in the archive. The Windows x64 binary is cross-compiled from a non-Windows host, which needs a one-off cargo install cargo-xwin plus rustup target add --toolchain 1.97.0 x86_64-pc-windows-msvc; on a Windows host the same Gradle task calls plain cargo build. The Linux x64 binary is cross-compiled the same way from a non-Linux host, which needs a one-off brew install zig cargo-zigbuild plus rustup target add --toolchain 1.97.0 x86_64-unknown-linux-musl; on a Linux host the same Gradle task calls plain cargo build, which there needs musl-tools from the distribution. The Rust core has its own checks:

cd core && cargo test --locked
cd core && cargo clippy --all-targets --locked -- -D warnings

The VS Code extension lives under vscode/ with its own npm toolchain; ./gradlew check also type-checks and runs its node:test suite, and ./gradlew buildVsixAarch64 buildVsixX64 buildVsixWin32X64 buildVsixLinuxX64 writes the platform-specific VSIX archives under vscode/.

verifyPlugin can download the configured IntelliJ compatibility target. The installable archive is written to build/distributions/orgbench-0.1.5.zip. Build and verification do not require an authenticated org and do not run the manual live-org scenario.

Troubleshooting

The support site https://orgbench.io/ answers questions about the plugin and files a ticket; the question-mark button in the tool window header opens it on any screen — in VS Code, the question-mark icon in the view title does the same — and the error screen offers the same link. Nothing is sent there automatically — the link opens only when you choose it.

A pricing procedure definition or recipe lost its usageSubtype although the target accepts it

The comparison's Metadata API version is the numeric minimum of the two orgs' own instanceApiVersion, and that figure comes from the Salesforce CLI's own cache — sf org list --json — not from asking the org directly. When that cache is stale it can report an org as 67.0 when the org has actually moved to 68.0 or beyond, and the release-gated tag rule then cuts usageSubtype/pricingUsageSubType RevenueCloud even though both orgs would accept it, and does so again on every later Update of the same row. The row's own message names the version it used (the comparison's API version 67.0 is below 68.0), so a version lower than you expect there is the sign to act on. What refreshes that cache is not established: listing the orgs again was measured (10.09.2026) NOT to refresh it, so sign the alias in again (a fresh authorization rewrites the CLI's record of the org), then compare again; a version read from the org itself instead of the cache is a registered residual.

Salesforce CLI is unavailable or incompatible

Run sf version --json in a terminal. Install or update Salesforce CLI, restart the IDE, and choose Restart. The plugin automatically checks the IDE PATH plus standard install locations. If sf is installed in a custom location, add its directory to the environment used to launch IntelliJ IDEA.

The Salesforce core process did not start

The plugin launches a bundled sf-core-server binary from its bin/ directory. If the tool window reports that the core process could not start or terminated, confirm the platform is supported (macOS arm64, macOS x64, Windows x64, or Linux x64) and that the plugin ZIP was installed from disk without unpacking. Reinstall the plugin if the bundled binary is missing. On Windows the bundled binary is unsigned, so SmartScreen or the antivirus may quarantine it on first launch.

On Windows, three further messages come from the core refusing to trust its own temporary workspace rather than from a startup failure: Could not read filesystem identity means the project or IDE cache directory sits on a filesystem (FAT/exFAT, or some network volumes) that does not give files a stable unique identity; plugin temp parent is not a regular directory means that directory is a reparse point, including a cloud-sync placeholder such as an unhydrated OneDrive folder; plugin temp parent must be writable only by its owner means its access control list grants write access beyond the current user. For the first two, move the project (and, if the message names the IDE cache path, that cache) to a local NTFS volume outside any cloud-synced folder. The third one is most often a directory created directly on a drive root, which inherits a write grant for a broad group such as Authenticated Users; a local NTFS volume does not help there. Move the directory under %USERPROFILE%, or drop the inherited grant with icacls <dir> /inheritance:r /grant %USERNAME%:(OI)(CI)F.

On Windows the core also refuses a metadata path that the platform cannot store faithfully — a path segment containing :, <, >, ", |, ? or *, a segment ending in a dot or a space, or a segment whose name before the first dot is a DOS device name such as CON, NUL, COM1 or LPT1 — while macOS keeps such names as they are, so a Page Layout whose label contains : or ? is still compared and deployed there; a path that starts with a drive letter such as C: and a path segment carrying a control character are refused on every platform. A deployment into a git target stops with The repository already contains this file under a different spelling that this filesystem treats as the same name: instead of overwriting a file whose name the filesystem treats as the one being written — a different letter case, a trimmed trailing dot or space, an 8.3 short name — because that write would silently replace a colleague's file. File names containing non-ASCII characters are exempt from this check: some volumes legitimately return them from a directory listing in a different unicode form of the same name, and refusing on that would block every later update of such a file.

A component whose own metadata file path the running operating system cannot store faithfully no longer disappears and no longer fails a whole deployment batch. Its row stays in the comparison table, is not deployable, and carries the reason This component cannot be deployed from this operating system: its metadata file path '<path>' is not a safe path here. — the path there is relative to the metadata root, so it never reveals where a repository lives on disk. This covers the components the plugin was able to read: when the operating system cannot even create such a file while retrieving from an org or materializing a branch, the component never reaches the comparison table, and what you see instead is one of the named refusals below. A component whose name yields no storable path at all on the running system, such as a component named CON on Windows, is blocked the same way and carries the reason This component cannot be deployed: no safe metadata file path can be derived for its name on this operating system. The refusals that remain are named too: a git operation that stops on an unsafe path names the offending file, one that stops on an entry that is not a regular file names that entry — by its last path segment alone when the plugin was writing to an absolute location, and by its repository-relative path when it was reading a branch, and one that cannot derive a repository path for a component names the component. A source repository whose sfdx-project.json lists package directories that all fail the path check now lists those entries in the message instead of reporting only that the repository is not an SFDX project; each listed entry is sanitized first, so an absolute or drive-letter entry appears as its last segment only, control characters are replaced and credential URLs lose their user information.

No aliases are listed

Use the + button next to the Source or Target dropdown to log in to an org and create an alias without leaving the IDE, or run sf org list --json in a terminal, authenticate aliases there and choose Reload Orgs. Entries without an alias are intentionally not shown.

While a browser login is running, the selection screen stays where it is with its controls disabled, shows the live progress line and offers Cancel; cancelling stops the CLI and leaves the browser tab open for you to close. A login that is not finished within ten minutes is reported as such. In a headless or container environment the Salesforce CLI refuses a browser login outright, and the plugin reports that instead — authenticate in a terminal there.

Reading an org fails although sf works

With Read orgs through set to Salesforce API (faster), the plugin reads an org — component listings, SOQL queries, object describes and REST sub-resources — by calling the Salesforce APIs directly over HTTPS with the session the Salesforce CLI holds for the alias, instead of starting sf for every read; it takes the same HTTPS_PROXY, HTTP_PROXY and NO_PROXY settings the CLI does. When a proxy or a firewall lets sf through but not these direct calls, the error details end with the transport error and Set "Read orgs through" to "Salesforce CLI" in the Orgbench settings and retry. Do exactly that — the Read orgs through dropdown under Settings | Tools | Orgbench in the IntelliJ plugin, orgbench.orgChannel set to cli in VS Code — and retry, with no restart: every read then runs through sf, slower but over the CLI's own connection. The same setting is the way out when the details say The Salesforce CLI did not reveal a session for the org '<alias>' (SF_TEMP_SHOW_SECRETS was not honoured). An expired session needs nothing: the plugin asks the CLI for a fresh session once and repeats the request. Only a second refusal in a row reaches the screen, and signing in again would not help there, since the CLI has just refreshed that very session: the message reads The org '<alias>' rejected the session the Salesforce CLI had just refreshed for it. (An org used by this operation rejected … where the failing org is not unambiguous), asks you to set Read orgs through to Salesforce CLI and retry, and keeps the org's own INVALID_SESSION_ID: Session expired or invalid in the details; a scratch org whose session the CLI could not refresh at all is told to sign in again before the first request instead; Check target stops at the object where that refusal arrives, as it does for an expired sign-in.

An org alias is no longer authenticated

When the Salesforce CLI reports that it could not refresh the stored authorization it needs, or that it has no local authorization at all, the error screen says so directly instead of opening with a wall of CLI diagnostics. Where the failing org is unambiguous, the message names it — the alias you picked, for a failure while the selection screen is loading its objects or a metadata type's list, and for Check target; the org's username, for a failure once the comparison or the deploy is under way — and asks you to sign in again with the + button next to the Source or Target dropdown, then retry. A refused metadata retrieve on Compare and a refused Quick Deploy name the alias you picked instead. Prepare Orgs, and the target check that Deploy runs before transferring records (with its Re-check), name the alias of the org whose read failed; for every other operation — including a permission transfer, except a refused metadata retrieve inside it that stops the whole operation (Validate only, All or nothing), which names the alias you picked — the same message deliberately names no org at all rather than guess a wrong one.

Two things are worth knowing about the edges of this behavior. A refused metadata retrieve is recognized by the same rule, because the CLI's answer is part of the text it keeps; when the retrieve is refused for another reason, the screen is headed by the general Salesforce operation failed. and the CLI's own answer stands under Show Details, except that a retrieve which did not finish within ten minutes has a heading of its own, Salesforce metadata retrieve for the org '<org>' did not finish within 10 minutes. Try again with fewer components selected, or try again later., with whatever the CLI printed under Show Details. In the retrieve's own sentences (for the org '…'), in the heading and under Show Details alike, the org is named by the label the screen shows for it, not by the address the CLI knows it by; the CLI's own words are left as they are, and where one CLI address stands behind both labels the address is kept; the retrieve of permissions that runs inside a Validate only or All or nothing deployment is named the same way. Everywhere else the diagnostic is not thrown away — on the error screen it is collapsed by default and one click away under Show Details, which in VS Code is the Details disclosure, and what it shows is the same sanitized text as before. On the selection screen, where there is no such toggle, Check target and Prepare Orgs put the same sanitized diagnostic right after the sentence, following Details:. A failure the plugin does not recognize at all keeps its previous wording too, with its full diagnostic under the same toggle.

A deployment into a repository is refused before anything is written

Three checks run before the first file is written, so a refusal leaves the repository as it was. The folder <path> of the target branch is a symbolic link or a file, not a real folder, so nothing is written through it. Replace it with a real folder in the branch, or deploy into another branch, then deploy again. means that a symlink (or a regular file) lies where a folder of the destination belongs — replace it with a real folder in the branch, or choose another branch. The target branch ignores <paths> (a .gitignore rule or an exclude file of the repository), so the commit could not include them. Remove that rule, or deploy into another branch, then deploy again. names up to three paths (then and N more) that a .gitignore rule or an exclude file of the repository covers — remove the rule or choose another branch. Deploying into a git repository needs git 2.25 or later: Orgbench passes the file paths to git on standard input. Update git, then deploy again. (followed by git's own answer) means the git on this machine does not accept file paths on standard input — update git; any other refusal at this point carries git's own answer alone (for example a leftover .git/index.lock) — act on what it says. The heading of the error screen is the text of the refusal itself for the three refusals above; for git's own answer it is The git repository operation did not complete. What git or the file system answered is under Details; fix what it names, then try again., and the answer is under Show Details.

Source and target are rejected as the same org

Choose aliases that resolve to different org IDs. Two different alias names can still point to one org.

No components or differences are shown

Confirm that the source user can query metadata and that the component is customizable. Target-only fields are intentionally omitted. Standard and namespaced components are listed — as Permissions only rows — so their permissions can be selected; their definitions still never travel. One managed shape stays hidden on purpose: a component whose packaging is visible only through manageableState, because its own name carries no namespace prefix, produces no row at all — the plugin cannot tell it from an unmanaged component by name, and a full row would deploy a managed definition. Metadata-identical fields appear as No change; by default the review Change filter hides them (only Add and Update are checked, unless the comparison has no Add and no Update row at all). On the first screen, the API Name and Label column filters each match a case-insensitive substring anywhere in the value, not just a leading prefix; switching Metadata Type loads that type's own component list without discarding selections already made for other types. Reload Orgs re-reads the alias list and then the component list of the type currently on screen; every other type's list is read again the next time you switch to it, and a selected component that a fresh list no longer carries is dropped from the selection at that moment. Restart and New Comparison re-read only the alias list. If loading an org's components failed outright, you are on the error screen instead; choosing Restart there returns a selection screen where that org is no longer selected, so picking the same alias again retries the load rather than doing nothing — unless that org's list had loaded before and components of it are still selected, in which case the org and your selection are kept and Reload Orgs retries the list.

Picking Custom Tabs loads standard tabs (standard-Account) through a second query, TabDefinition, on top of the ordinary CustomTab metadata listing. If that query fails — an unauthenticated source, an insufficient permission, or a transient Salesforce error — the entire Custom Tabs list fails, including the custom tabs the ordinary listing had already fetched; there is no other route to the custom tabs alone. Retry the load, and if the failure persists, tabs are unavailable entirely until whatever is blocking TabDefinition for that org is fixed — compare other metadata types in the meantime.

A target-object row is disabled

The target object does not exist. Either create the object outside this plugin and compare again, or select its custom CustomObject row in the same deployment so the object is created before its fields.

An alias changed after review

The plugin intentionally aborts before mutation if an alias no longer maps to the reviewed username and org ID. Choose Back or New Comparison and repeat the comparison.

Deployment or permission transfer has failed rows

Open Show Details for sanitized Salesforce messages. Check Metadata API permissions, field dependencies, target validation rules, and an exact match of the Container column — the metadata fullName, not the Label column, which is the Setup display name and can legitimately differ from it. Missing target containers are skipped (see the Skipped filter of the permission table); a failing permission component is isolated by container when Salesforce returns a component-specific failure. If every permission row is Not Attempted with the same message, the failure happened earlier, reading the Permission Set/Profile catalog itself, before any container-specific deployment was attempted; the field metadata rows above it are unaffected.

Cancellation or temporary cleanup reports an error

Choose Restart to start a fresh workflow and retry cleanup owned by the current plugin session. If the error persists, close the project after the active Salesforce CLI process has stopped and inspect the IDE system directory before removing anything manually.

Manual Validation

The live-org smoke test is intentionally separate from automated builds because it mutates Salesforce metadata and permissions. Follow docs/manual-smoke-test.md only with disposable source and target orgs, record each expected result, and dispose of the test orgs afterward.