diff --git a/.prettierignore b/.prettierignore
new file mode 100644
index 0000000..5be1e84
--- /dev/null
+++ b/.prettierignore
@@ -0,0 +1,2 @@
+# oclif message files use parser-specific Markdown; preserve command examples.
+messages/**
diff --git a/.sfdevrc.json b/.sfdevrc.json
index 66121e1..87e01b2 100644
--- a/.sfdevrc.json
+++ b/.sfdevrc.json
@@ -5,6 +5,31 @@
   "wireit": {
     "test": {
       "dependencies": ["test:compile", "test:only", "lint"]
+    },
+    "test:only": {
+      "command": "nyc mocha \"test/**/*.test.ts\"",
+      "env": {
+        "FORCE_COLOR": "2"
+      },
+      "files": [
+        "test/**/*.ts",
+        "test/**/*.mjs",
+        "src/**/*.ts",
+        "**/tsconfig.json",
+        ".mocha*",
+        "!*.nut.ts",
+        ".nycrc",
+        "package.json",
+        "yarn.lock"
+      ],
+      "output": [],
+      "dependencies": ["compile"]
+    },
+    "compile": {
+      "command": "tsc -p . --pretty --incremental",
+      "files": ["src/**/*.ts", "**/tsconfig.json", "messages/**", "package.json", "yarn.lock"],
+      "output": ["lib/**", "*.tsbuildinfo"],
+      "clean": "if-file-deleted"
     }
   }
 }
diff --git a/FLOW_DEPENDENCIES.md b/FLOW_DEPENDENCIES.md
new file mode 100644
index 0000000..bfccc3f
--- /dev/null
+++ b/FLOW_DEPENDENCIES.md
@@ -0,0 +1,21 @@
+# Flow dependency analysis
+
+`flow dependencies` reads direct relationships for a selected Flow and an explicit scan scope. Run it from the plugin-flow checkout after compiling:
+
+```bash
+node bin/run.js flow dependencies \
+  --target-org my-org \
+  --flow-name Account_Onboarding \
+  --scan-flow FirstCaller \
+  --scan-flow SecondCaller
+```
+
+Names, definition IDs and version IDs are resolved from the authenticated org. `--scan-flow` is optional and repeatable; it selects candidate caller Flows whose metadata will be inspected. It does not request an automatic org-wide scan. The root and explicit caller list are capped at 20 Flow definitions.
+
+The command reads selected Flow metadata and queries the dependency API for incoming/outgoing records. API-reported Apex callers can be displayed without supplying an Apex class name. A relationship to a Flow definition does not establish a dependency on a particular inactive version and is not a deletion assessment.
+
+Use `--version-policy latest` (the default) or `--version-policy active`. Active requires an active version for every explicitly selected Flow and does not silently fall back. Flow names are DeveloperName values; `--namespace` applies to the root and explicit scan Flows.
+
+Console output includes the root identity and incoming/outgoing evidence. `--json` also returns scan scope, provider status and coverage warnings. Empty or limited dependency-API results do not prove that no relationship exists.
+
+This command is read-only. Its supported scope is direct relationships: no recursive traversal, complete caller enumeration, Apex source parser, arbitrary runtime reference discovery, manifest generation or delete eligibility is claimed. Use version-management assessment for normal-delete eligibility.
diff --git a/FLOW_VERSION_MANAGEMENT.md b/FLOW_VERSION_MANAGEMENT.md
new file mode 100644
index 0000000..41f7f34
--- /dev/null
+++ b/FLOW_VERSION_MANAGEMENT.md
@@ -0,0 +1,102 @@
+# Flow version management
+
+Run these commands from the plugin-flow checkout after installing dependencies and compiling the plugin. Build and link the Flow Node library using the repository development setup first. The commands use the existing Salesforce CLI org authorization and accept any authenticated org alias and Flow API name.
+
+## Backend compatibility
+
+Version management requires API 67.0 or later and these authenticated server operations:
+
+| Command path               | Required operation                                             |
+| -------------------------- | -------------------------------------------------------------- |
+| List and retention catalog | `POST /connect/interaction/flow-versions/list`                 |
+| Normal deletion preview    | `POST /connect/interaction/flow-versions/deletion-assessment`  |
+| Normal deletion            | `DELETE /tooling/sobjects/Flow/{versionId}`                    |
+| Force preview              | `POST /connect/interaction/flow-versions/force-delete/preview` |
+| Force execution            | `POST /connect/interaction/flow-versions/force-delete`         |
+
+The API version prefix is selected from the authenticated Connection. Availability of the CLI package does not establish that these server operations are installed in an org. Authentication, request failures and malformed responses are reported as errors; the client does not substitute inferred eligibility or counts.
+
+The production integration delegates inventory, eligibility and retention selection to shared B services, and force deletion to the D API. Those service bindings are still being finalized. The currently supported wire contracts and interim retention behavior below remain explicit until that integration is available.
+
+## List versions
+
+Choose exactly one scope: `--flow <API name>` or `--all`. Use a qualified API name for a namespaced Flow.
+
+```bash
+node bin/run.js flow version list --target-org my-org --api-version 67.0 --flow Account_Onboarding
+node bin/run.js flow version list --target-org my-org --api-version 67.0 --all --json
+node bin/run.js flow version list --target-org my-org --all --status Obsolete --older-than 90d --min-percent 80 --deletable
+```
+
+The server supplies version metadata, actual org version limit, counts and normal deletion eligibility. The client follows pagination and retains completeness information. Null values remain unavailable; they are never replaced by zero. `PASS` displays Yes, `BLOCKED` displays No with its reason, and `ERROR` means the row was not fully assessed.
+
+The current list contract derives age from Created Date. Production B1 specifies Last Modified Date. The backend and client must adopt the same age basis when the shared B1 contract is bound; the client does not silently reinterpret server age values.
+
+## Preview and delete explicit versions
+
+Version lists and inclusive ranges are supported, with up to 200 distinct numbers. Selection is resolved to exact definition/version identities; Active or latest versions are never substituted for missing numbers.
+
+```bash
+node bin/run.js flow version delete \
+  --target-org my-org \
+  --api-version 67.0 \
+  --flow Account_Onboarding \
+  --versions 1,2,4-6 \
+  --dry-run
+```
+
+The same command works on one line. Existing bare value syntax is also accepted; Boolean options retain their dashes:
+
+```bash
+node bin/run.js flow version delete target-org my-org flow Account_Onboarding versions 1,2,4-6 --dry-run
+```
+
+Omit `--dry-run` to display the assessed plan and request confirmation. The default is No; timeout or cancellation closes the prompt without deleting. Explicit `--yes` is required for normal noninteractive or JSON execution.
+
+Every exact target is rechecked after confirmation. A blocked or known-failed version does not prevent eligible siblings from being processed. Normal deletion does not abandon interviews or remove references. A lost or inconclusive mutation response remains `UNKNOWN` and stops subsequent mutations; it is not automatically retried.
+
+The client currently preserves the last remaining version with a separately labeled client policy. This is not a claimed server restriction. The product decision about deleting the empty definition remains open; managed-package restrictions remain server-owned.
+
+## Retention cleanup
+
+Preview is the default:
+
+```bash
+node bin/run.js flow version prune --target-org my-org --flow Account_Onboarding --keep-latest 5 --older-than 90d
+node bin/run.js flow version prune --target-org my-org --all --keep-latest 5 --older-than 90d --dry-run --json
+```
+
+`--execute` requests interactive confirmation. `--yes` is the explicit noninteractive execution option. Both are mutually exclusive with `--dry-run`. Force deletion is never used by retention cleanup.
+
+The current client reads the complete unfiltered catalog, keeps Active and the latest N, and adds an interim rollback safeguard based on the newest Obsolete `statusChangeDate`. It keeps all newest ties, or all Obsolete versions when their timestamps are all null. Packaging can change that timestamp, so it is not proof of previous activation. Missing required metadata or an incomplete catalog prevents selection.
+
+Only remaining inactive versions old enough according to server `ageDays` and marked `PASS`/deletable become candidates. Fresh identity, eligibility and retention checks precede each deletion; confirmation cannot add or substitute targets.
+
+Production B1 protects Active and the latest N and uses Last Modified Date. Shared candidate selection will replace the interim client rule after its request/response contract is agreed. The current command does not claim B1 parity.
+
+## Force-delete one version
+
+Force deletion is manual, requires interactive terminals and accepts exactly one positive version number. It uses dedicated preview/execute operations; no force flag is added to Tooling DELETE.
+
+```bash
+node bin/run.js flow version delete --target-org my-org --flow Account_Onboarding --versions 2 --force --dry-run
+node bin/run.js flow version delete --target-org my-org --flow Account_Onboarding --versions 2 --force
+```
+
+The CLI displays actual server impact and eligibility, then requires the exact Flow API name and version number. `--yes` cannot approve force execution. Tokens and typed answers are omitted from reports, console output and JSON. Force execution with JSON still requires interactive input/output and sends human prompts to stderr.
+
+Force execution requires a backend that enforces the opt-in Force Delete Flow Versions permission, org-level disable, impact-bound token authorization, interview/registration cleanup, orchestration handling and audit. These are server responsibilities. Unsupported impact data remains unavailable, and an ineligible preview never executes. Backend production readiness must be established independently of client tests.
+
+## Reports and scripting
+
+JSON schemas are checked in under `schemas/flow-version-{list,delete,prune,force-delete}.json`. Normal deletion uses report contract 2; list, retention and force reports use contract 1. Reports preserve exact identities, backend reasons and confirmed versus uncertain mutation outcomes.
+
+| Result                                                  | Exit |
+| ------------------------------------------------------- | ---- |
+| Completed preview, cancellation, or successful deletion | 0    |
+| Deletion blocked without another failure                | 1    |
+| Failed, unassessed, uncertain, or unattempted execution | 2    |
+
+List exits 1 for truncation or an assessment error, and 0 for a complete result that may include blocked rows. Invalid input, authentication and whole-request failures return command errors. The product wording about failed dry-run requests remains open; a completed preview retains its per-version blockers/errors and exits 0.
+
+Client tests use isolated providers, native Connection mocks and terminal fixtures. They do not establish live server authorization, audit, abandonment or rollback behavior.
diff --git a/README.md b/README.md
index 24efabf..cc92901 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# Salesforce Flow Test Plugin
+# Salesforce Flow CLI Plugin
 
 ![npm (scoped)](https://img.shields.io/npm/v/@salesforce/plugin-flow)
 [![License](https://img.shields.io/badge/License-Apache--2.0-blue.svg)](https://opensource.org/license/apache-2-0)
@@ -6,7 +6,9 @@
 
 ## Introduction
 
-This is an oclif plugin that supports the Salesforce Flow Test commands.
+This oclif plugin provides Salesforce Flow test commands, dependency analysis, and version management. Flow tests use `@salesforce/apex-node`; version-management commands use `@salesforce/flow-node` from the [flows repository](https://github.com/forcedotcom/flows).
+
+See [Flow version management](FLOW_VERSION_MANAGEMENT.md) and [Flow dependency analysis](FLOW_DEPENDENCIES.md) for command examples and backend compatibility.
 
 ### Building the Plugin
 
@@ -43,6 +45,25 @@ $ bin/dev.js flow run test -o myOrg@example.com
 
 <br />
 
+### Developing with Flow Node
+
+Clone `forcedotcom/flows` beside this checkout. The development dependency is pinned to a Flow Node Git commit until its first npm release and requires access to the private `forcedotcom/flows` repository. A public plugin release must first use a published Flow Node npm version. To use your local library while developing:
+
+```bash
+cd ../flows
+yarn install --frozen-lockfile
+yarn build
+yarn link --link-folder .yarn-links
+
+cd ../plugin-flow
+yarn install --frozen-lockfile
+yarn link --link-folder ../flows/.yarn-links @salesforce/flow-node
+yarn compile
+node bin/run.js flow version list --help
+```
+
+Rebuild Flow Node after library changes. The local link uses the same public package entry point as the installed dependency. If Yarn is not on your PATH, use `corepack yarn`.
+
 ### Running the Test Suite
 
 Test the test suite locally by building the project first and then running the tests.
@@ -58,8 +79,77 @@ $ yarn test
 
 <!-- commands -->
 
+- [`sf flow dependencies`](#sf-flow-dependencies)
 - [`sf flow get test`](#sf-flow-get-test)
 - [`sf flow run test`](#sf-flow-run-test)
+- [`sf flow version delete`](#sf-flow-version-delete)
+- [`sf flow version list`](#sf-flow-version-list)
+- [`sf flow version prune`](#sf-flow-version-prune)
+
+## `sf flow dependencies`
+
+Inspect direct Flow dependencies and references in a target org.
+
+```
+USAGE
+  $ sf flow dependencies -o <value> -f <value> [--json] [--flags-dir <value>] [--api-version <value>] [--namespace
+    <value>] [--scan-flow <value>...] [--version-policy latest|active]
+
+FLAGS
+  -f, --flow-name=<value>        (required) API DeveloperName of the root Flow (without a namespace prefix).
+  -o, --target-org=<value>       (required) Username or alias of the target org. Not required if the `target-org`
+                                 configuration variable is already set.
+      --api-version=<value>      Override the api version used for api requests made by this command
+      --namespace=<value>        Namespace of the root and scanned Flows; omit for unmanaged Flows.
+      --scan-flow=<value>...     Additional caller Flow DeveloperName to inspect; repeat for more Flows (20 total
+                                 including the root).
+      --version-policy=<option>  [default: latest] Select the latest or active version of each explicitly named Flow.
+                                 <options: latest|active>
+
+GLOBAL FLAGS
+  --flags-dir=<value>  Import flag values from a directory.
+  --json               Format output as json.
+
+DESCRIPTION
+  Inspect direct Flow dependencies and references in a target org.
+
+  Resolve the root Flow from --flow-name in --target-org, then read the selected version's metadata and extract its
+  subflow references. Names, definition IDs, and version IDs are resolved from the org on every run; no fixture names or
+  IDs are built into the command. Inspect additional candidate caller Flows when explicitly provided with --scan-flow.
+  Also query MetadataComponentDependency for incoming and outgoing references to the root definition and selected
+  version.
+
+  --scan-flow is optional and repeatable. It defines which candidate caller Flows to inspect; it is not an automatic
+  search for every caller in the org. Without it, the command still reads the root Flow and queries the dependency API,
+  but incoming references can be incomplete.
+
+  The default version policy is latest, including Draft versions. The active policy requires an active version for every
+  selected Flow; it does not fall back silently. Flow names are DeveloperName values; use --namespace separately. The
+  namespace applies to the root and explicitly selected scan Flows.
+
+  This read-only command does not deploy, activate, execute, or delete metadata. It does not scan Apex source, resolve
+  arbitrary runtime references, traverse dependencies recursively, generate a manifest, or claim a complete org-wide
+  impact analysis. Empty dependency-API results do not mean no dependencies. Console output shows the root identity and
+  incoming/outgoing relationships with their evidence. Use --json for structured results, including scan scope,
+  dependency-API status, and coverage warnings.
+
+EXAMPLES
+  Inspect any Flow by its API DeveloperName in an authenticated org:
+
+    $ sf flow dependencies --target-org my-org --flow-name MyFlowApiName
+
+  Also inspect two candidate caller Flows without changing the command implementation:
+
+    $ sf flow dependencies --target-org my-org --flow-name MyFlowApiName --scan-flow FirstCaller --scan-flow \
+      SecondCaller
+
+  Select active versions in a namespace and return structured evidence and coverage information:
+
+    $ sf flow dependencies --target-org my-org --namespace acme --flow-name MyFlowApiName --version-policy active \
+      --json
+```
+
+_See code: [src/commands/flow/dependencies.ts](https://github.com/salesforcecli/plugin-flow/blob/v2.0.2/src/commands/flow/dependencies.ts)_
 
 ## `sf flow get test`
 
@@ -116,7 +206,7 @@ EXAMPLES
       me@my.org'
 ```
 
-_See code: [src/commands/flow/get/test.ts](https://github.com/salesforcecli/plugin-flow/blob/2.0.2/src/commands/flow/get/test.ts)_
+_See code: [src/commands/flow/get/test.ts](https://github.com/salesforcecli/plugin-flow/blob/v2.0.2/src/commands/flow/get/test.ts)_
 
 ## `sf flow run test`
 
@@ -216,6 +306,302 @@ FLAG DESCRIPTIONS
     Default is all flow tests. If you specify --tests, you can't specify --class-names.
 ```
 
-_See code: [src/commands/flow/run/test.ts](https://github.com/salesforcecli/plugin-flow/blob/2.0.2/src/commands/flow/run/test.ts)_
+_See code: [src/commands/flow/run/test.ts](https://github.com/salesforcecli/plugin-flow/blob/v2.0.2/src/commands/flow/run/test.ts)_
+
+## `sf flow version delete`
+
+Delete selected Flow versions normally, or force-delete one version with interactive confirmation.
+
+```
+USAGE
+  $ sf flow version delete -o <value> -f <value> --versions <value> [--json] [--flags-dir <value>] [--api-version
+    <value>] [--namespace <value>] [--dry-run] [-y] [--force]
+
+FLAGS
+  -f, --flow=<value>         (required) API DeveloperName of the Flow, without its namespace prefix.
+  -o, --target-org=<value>   (required) Username or alias of the target org. Not required if the `target-org`
+                             configuration variable is already set.
+  -y, --yes                  Approve normal deletion without prompting; ignored by --force, which always requires typed
+                             confirmation.
+      --api-version=<value>  Override the api version used for api requests made by this command
+      --dry-run              Preview the selected normal or force deletion without mutating the org.
+      --force                Force-delete one version using an interactive impact preview and typed Flow name/version
+                             confirmation.
+      --namespace=<value>    Namespace of the Flow; omit for an unmanaged Flow.
+      --versions=<value>     (required) Explicit version numbers or inclusive ranges, for example 1,2,4-6. With --force,
+                             exactly one version number is required.
+
+GLOBAL FLAGS
+  --flags-dir=<value>  Import flag values from a directory.
+  --json               Format output as json.
+
+DESCRIPTION
+  Delete selected Flow versions normally, or force-delete one version with interactive confirmation.
+
+  Select versions of one Flow by API DeveloperName and resolve exact version IDs in the target org. No Flow name, org or
+  version ID is hardcoded. Use --namespace separately for namespaced Flows. API 67.0 or later is required for the
+  existing deletion-assessment API.
+
+  --versions accepts a single number, comma-separated numbers or inclusive ranges, for example 1,2,4-6, with at most 200
+  distinct selected versions. Every requested number receives a result. Missing, Active, and otherwise blocked versions
+  do not reject the entire selection. No replacement version is chosen when an exact target disappears.
+
+  --dry-run resolves the selection and calls POST /connect/interaction/flow-versions/deletion-assessment. It shows
+  actual backend PASS, BLOCKED or ERROR results and missing-version errors without sending DELETE. A completed dry run
+  exits 0, including blocked or errored items. A whole-request failure still returns an error. Preview is an
+  observation, not a guarantee that a later deletion will succeed.
+
+  For NORMAL execution, the SDK rechecks exact target identity and freshly assesses each version after confirmation.
+  BLOCKED versions preserve the backend's complete reason and evidence and do not stop eligible siblings. Assessment
+  ERROR is a failed item and does not authorize DELETE. Only PASS proceeds to DELETE /tooling/sobjects/Flow/{versionId}.
+  A conclusive successful deletion reports SUCCEEDED; a conclusive delete rejection reports FAILED with the platform
+  error. Each version is independent; earlier successes are not rolled back.
+
+  The existing client preservation safeguard retains at least one version while the product decision about deleting the
+  last remaining version is open. It applies per item and is explicitly identified as client policy, not an invented
+  backend restriction. There is no blanket protection for the latest inactive version when another version remains.
+  Client checks do not provide an atomic concurrency guarantee.
+
+  Value options also accept bare name/value pairs: target-org my-org flow MyFlow versions 1,2,4-6. This is equivalent to
+  --target-org my-org --flow MyFlow --versions 1,2,4-6, and both forms can be mixed. Supported bare names are
+  target-org, flow, versions, namespace and api-version. Boolean options such as --dry-run, --yes and --json still
+  require dashes. Duplicate value options and malformed arguments are rejected.
+
+  Without --yes, NORMAL interactive execution displays the complete plan and waits 60 seconds for confirmation,
+  defaulting to no. Timeout or Ctrl-C closes the prompt and cancels without deletion. Non-interactive and JSON NORMAL
+  execution require --yes. --dry-run never requires confirmation. Confirmation covers the exact selected targets, not
+  arbitrary org changes. FORCE uses the separate typed confirmation described below.
+
+  JSON contract 2 contains the assessed plan and per-version execution results, including the source of a reason. Exit 0
+  means all requested deletions succeeded or a dry run completed. Exit 1 means execution had blocked items and no failed
+  or uncertain items. Exit 2 means any item failed, has an unconfirmed deletion outcome, or was not attempted after
+  execution stopped. Cancellation exits 0.
+
+  Transport retries and redirects are disabled for DELETE. Native authentication refresh remains in the Salesforce SDK.
+  A timeout, lost response or inconclusive server error is reported as UNKNOWN with targetDeleted null; remaining
+  versions are NOT_ATTEMPTED. These exceptional results must not be relabeled as confirmed failures, retried
+  automatically, or treated as rollback. Org changes stop further execution. Normal deletion does not abandon interviews
+  or remove references.
+
+  --force selects the separate C6 backend and accepts exactly one version number, with no commas or ranges. It never
+  adds a force flag to Tooling DELETE. It requires both input and output terminals to be interactive, including --force
+  --dry-run. The backend preview supplies eligibility and impact. A blocked preview never executes. --dry-run displays
+  the force preview without prompting or deleting; a completed preview exits 0.
+
+  Force execution always displays the impact and requires typing the exact Flow API name and version number into two
+  empty prompts. --yes is ignored in force mode and cannot bypass either prompt. Timeout, Ctrl-C or a mismatch cancels.
+  The confirmation window is normally two minutes and never shorter than one minute; an expiring preview requires a
+  fresh command. JSON force execution also requires an interactive stderr: the human preview and prompts go to stderr,
+  and the final JSON stays on stdout. Redirected input/output and CI execution are rejected.
+
+  Force preview calls POST /connect/interaction/flow-versions/force-delete/preview with exact version and definition
+  IDs. Execution sends only the private, single-use confirmation token to POST
+  /connect/interaction/flow-versions/force-delete. Typed text and CLI flags are not sent to the backend. Tokens are
+  never included in console/JSON reports. A stale or rejected token requires a fresh preview and typed confirmation; it
+  is not automatically retried. A lost or inconclusive execution response is UNKNOWN and requires reconciliation before
+  another attempt.
+
+  Force JSON uses mode FORCE and contract 1, documented in schemas/flow-version-force-delete.json. Normal mode retains
+  contract 2 in schemas/flow-version-delete.json. Force execution exits 0 for success or cancellation, 1 for blocked,
+  and 2 for failed or uncertain. Force execution requires a backend that enforces the dedicated Force Delete Flow
+  Versions permission, org-level disable, token authorization, audit and runtime cleanup. CLI interactivity does not
+  replace backend authorization.
+
+EXAMPLES
+  Assess a mixed selection without deleting anything:
+
+    $ sf flow version delete --target-org my-org --flow MyFlow --versions 1,2,4-6 --dry-run
+
+  Select versions and confirm interactively:
+
+    $ sf flow version delete --target-org my-org --flow MyFlow --versions 1-3
+
+  Use equivalent bare name/value pairs:
+
+    $ sf flow version delete target-org my-org flow MyFlow versions 1-3
+
+  Approve the exact selection and return JSON:
+
+    $ sf flow version delete --target-org my-org --flow MyFlow --versions 1-3 --yes --json
+
+  Preview force-deletion impact for one version from an interactive terminal:
+
+    $ sf flow version delete --target-org my-org --flow MyFlow --versions 2 --force --dry-run
+
+  Review force-deletion impact and type the Flow name and version to confirm:
+
+    $ sf flow version delete --target-org my-org --flow MyFlow --versions 2 --force
+```
+
+_See code: [src/commands/flow/version/delete.ts](https://github.com/salesforcecli/plugin-flow/blob/v2.0.2/src/commands/flow/version/delete.ts)_
+
+## `sf flow version list`
+
+List Flow versions, reference and interview counts, and deletion eligibility.
+
+```
+USAGE
+  $ sf flow version list -o <value> [--json] [--flags-dir <value>] [--api-version <value>] [-f <value> | --all]
+    [--namespace <value>] [--status <value>] [--older-than <value>] [--min-percent <value>] [--deletable]
+
+FLAGS
+  -f, --flow=<value>         Exact Flow API name, qualified with its namespace when applicable; mutually exclusive with
+                             --all.
+  -o, --target-org=<value>   (required) Username or alias of the target org. Not required if the `target-org`
+                             configuration variable is already set.
+      --all                  List versions for all Flows in the org; mutually exclusive with --flow.
+      --api-version=<value>  Override the api version used for api requests made by this command
+      --deletable            Show backend PASS versions; the server retains assessment errors.
+      --min-percent=<value>  Show Flows at or above this percentage of their configured version limit (0-100).
+      --namespace=<value>    Unsupported by the Core list API; use --flow with the qualified API name instead.
+      --older-than=<value>   Show versions at least this many whole days old since CreatedDate, from 0d to 36500d.
+      --status=<value>       Filter by active, inactive (all non-Active), draft, obsolete, invaliddraft or underreview;
+                             case-insensitive.
+
+GLOBAL FLAGS
+  --flags-dir=<value>  Import flag values from a directory.
+  --json               Format output as json.
+
+DESCRIPTION
+  List Flow versions, reference and interview counts, and deletion eligibility.
+
+  Read Flow versions through the authenticated Core Connect list API. Choose exactly one scope: --flow for an exact Flow
+  API name, including its namespace prefix when applicable, or --all for every Flow in the org. No Flow name, org, count
+  or version limit is hardcoded. The Core list contract has no separate namespace filter; --namespace is rejected. Use a
+  qualified --flow name instead.
+
+  The console includes the A3/C1 fields: Flow version name, version number, status, age, creator, creation date,
+  last-modified date, reference count, paused and failed interview counts, and whether the version is deletable, with
+  the full server reason when it is not. Standard Salesforce CLI tables wrap complete values. Normal-width consoles use
+  Field/Value tables. JSON preserves raw IDs and server values.
+
+  API 67.0 or later and POST /connect/interaction/flow-versions/list are required. HTTP 201 is success even when
+  versions are BLOCKED or ERROR. The SDK follows every nextOffset, including empty pages. This command does not query
+  Tooling inventory or the separate deletion-assessment API.
+
+  Native status filters are case-insensitive: active, draft, obsolete, invaliddraft and underreview. Inactive is a
+  compatibility alias: the SDK retrieves list pages without a server status filter, then displays non-Active rows. ERROR
+  rows with unavailable status remain visible. --older-than accepts whole days from CreatedDate, from 0d to 36500d.
+  --deletable requests PASS rows; the server also retains ERROR rows. --min-percent uses the Flow's complete version
+  count before filtering and actual org version limit. The CLI preserves the server's integer percentage. A zero limit
+  and null percentage remain explicit; its product filtering rule is still open.
+
+  PASS displays Deletable Yes. BLOCKED displays No and the complete backend message. ERROR displays Error: that version
+  was not fully assessed. The CLI does not create local blockers or replace unavailable metadata/counts with zero. All
+  three counts come directly from the list response. The reference-count counting unit remains subject to product-owner
+  confirmation.
+
+  JSON now follows Core contractVersion 1 with grouped flows and direct per-version counts, deletable, outcome,
+  reasonCode and message. It replaces obsolete client format 6 and its flat rows and repeated error arrays.
+  returnedVersionCount is the displayed aggregate. candidateVersionCount is the server's candidate/prefix metric, not a
+  complete org total. A server listTruncated flag or any per-version ERROR produces exit status 1 after the report is
+  returned. BLOCKED alone leaves status 0. A failed or malformed whole request returns a typed error instead of
+  fabricated inventory.
+
+  No Flow, interview, reference or business record is modified. This command never calls Tooling DELETE and requires no
+  confirmation. A later deletion still runs current backend validation.
+
+EXAMPLES
+  List versions of one Flow:
+
+    $ sf flow version list --target-org my-org --flow MyFlow
+
+  List versions of a namespaced Flow using its qualified API name:
+
+    $ sf flow version list --target-org my-org --flow billing__MyFlow
+
+  Find Flows using at least 80 percent of their configured version limit:
+
+    $ sf flow version list --target-org my-org --all --min-percent 80
+
+  Return backend PASS versions and any assessment errors as JSON:
+
+    $ sf flow version list --target-org my-org --flow MyFlow --deletable --json
+
+  Return older inactive versions as JSON:
+
+    $ sf flow version list --target-org my-org --flow MyFlow --status inactive --older-than 90d --json
+```
+
+_See code: [src/commands/flow/version/list.ts](https://github.com/salesforcecli/plugin-flow/blob/v2.0.2/src/commands/flow/version/list.ts)_
+
+## `sf flow version prune`
+
+Preview or execute retention cleanup for one Flow or all Flows in an org.
+
+```
+USAGE
+  $ sf flow version prune -o <value> [--json] [--flags-dir <value>] [--api-version <value>] [-f <value> | --all]
+    [--keep-latest <value>] [--older-than <value>] [--dry-run | --execute | -y]
+
+FLAGS
+  -f, --flow=<value>         Fully qualified Flow API name; choose --flow or --all.
+  -o, --target-org=<value>   (required) Username or alias of the target org. Not required if the `target-org`
+                             configuration variable is already set.
+  -y, --yes                  Explicitly authorize deletion of the planned cleanup candidates without prompting.
+      --all                  Evaluate every Flow in the org, after paging the complete C1 catalog.
+      --api-version=<value>  Override the api version used for api requests made by this command
+      --dry-run              Explicitly preview the retention plan without deletion; preview is the default.
+      --execute              Display the exact plan and request interactive confirmation before deletion.
+      --keep-latest=<value>  [default: 5] Number of latest versions to keep by version number (at least 1; default 5).
+      --older-than=<value>   [default: 90d] Minimum age in UTC days, such as 90d (inclusive; default 90d).
+
+GLOBAL FLAGS
+  --flags-dir=<value>  Import flag values from a directory.
+  --json               Format output as json.
+
+DESCRIPTION
+  Preview or execute retention cleanup for one Flow or all Flows in an org.
+
+  Defaults to a preview. Core's C1 list is paged in full, without status, age or deletable filters, before the CLI
+  applies the retention policy. No new backend endpoint is required. Use API 67.0 or later and a Core server that
+  returns statusChangeDate. A server omitting that field produces an actionable error rather than guessing a rollback
+  version.
+
+  Keep the Active version, the latest N by version number (default 5), and the Obsolete version with the newest
+  statusChangeDate. A null timestamp never wins over a real timestamp. As a conservative interim rule, keep every
+  version tied at the newest timestamp; when all Obsolete timestamps are null, keep all Obsolete versions. Packaging can
+  stamp statusChangeDate, so this rule is not proof of the historical previous activation. Do not substitute
+  lastModifiedDate for activation history. This interim rule is distinct from the production B1 rule, which uses Last
+  Modified Date and protects Active plus the latest N. The client will adopt shared B1 selection after its contract is
+  agreed.
+
+  Only inactive versions outside those protections, old enough according to Core's ageDays (default at least 90 UTC
+  days), and marked PASS/deletable by Core are candidates. ERROR is not deletable. Incomplete catalogs or missing
+  required policy metadata do not authorize deletion.
+
+  Use --execute for an interactive confirmation, which defaults to no and allows 60 seconds. Use --yes to explicitly
+  authorize non-interactive execution. These options and --dry-run are mutually exclusive. JSON/non-interactive
+  execution requires --yes. Without either execution option, nothing is deleted, even in an interactive terminal.
+
+  Execution preserves the exact previewed version IDs. Each candidate goes through the existing C2 normal-delete
+  service: current identity, fresh deletion assessment, a fresh complete C1 retention check, and then Tooling DELETE
+  only if still eligible. Known blocked and failed items do not stop eligible siblings. An unconfirmed deletion outcome
+  or org-context change stops later mutations. Client checks cannot atomically reserve retention state against other
+  writers. No force deletion, reference removal or interview abandonment is performed.
+
+  JSON contract 1 includes the policy, every kept/candidate/blocked/error row with reasons, and execution results. A
+  completed preview or cancellation exits 0. Execution exits 1 for blocked items and 2 for failed, unassessed or
+  uncertain items. A whole-request failure is an error.
+
+EXAMPLES
+  Preview one Flow using the default keep count and age:
+
+    $ sf flow version prune --target-org my-org --flow MyFlow
+
+  Preview an explicit retention rule:
+
+    $ sf flow version prune --target-org my-org --flow MyFlow --keep-latest 5 --older-than 90d --dry-run
+
+  Review and confirm interactively:
+
+    $ sf flow version prune --target-org my-org --flow MyFlow --execute
+
+  Explicitly authorize org-wide cleanup and return JSON:
+
+    $ sf flow version prune --target-org my-org --all --keep-latest 5 --older-than 90d --yes --json
+```
+
+_See code: [src/commands/flow/version/prune.ts](https://github.com/salesforcecli/plugin-flow/blob/v2.0.2/src/commands/flow/version/prune.ts)_
 
 <!-- commandsstop -->
diff --git a/command-snapshot.json b/command-snapshot.json
index 9d86e69..1b286ea 100644
--- a/command-snapshot.json
+++ b/command-snapshot.json
@@ -1,4 +1,21 @@
 [
+  {
+    "alias": [],
+    "command": "flow:dependencies",
+    "flagAliases": [],
+    "flagChars": ["f", "o"],
+    "flags": [
+      "api-version",
+      "flags-dir",
+      "flow-name",
+      "json",
+      "namespace",
+      "scan-flow",
+      "target-org",
+      "version-policy"
+    ],
+    "plugin": "@salesforce/plugin-flow"
+  },
   {
     "alias": [],
     "command": "flow:get:log",
@@ -47,5 +64,64 @@
       "tests"
     ],
     "plugin": "@salesforce/plugin-flow"
+  },
+  {
+    "alias": [],
+    "command": "flow:version:delete",
+    "flagAliases": [],
+    "flagChars": ["f", "o", "y"],
+    "flags": [
+      "api-version",
+      "dry-run",
+      "flags-dir",
+      "flow",
+      "force",
+      "json",
+      "namespace",
+      "target-org",
+      "versions",
+      "yes"
+    ],
+    "plugin": "@salesforce/plugin-flow"
+  },
+  {
+    "alias": [],
+    "command": "flow:version:list",
+    "flagAliases": [],
+    "flagChars": ["f", "o"],
+    "flags": [
+      "all",
+      "api-version",
+      "deletable",
+      "flags-dir",
+      "flow",
+      "json",
+      "min-percent",
+      "namespace",
+      "older-than",
+      "status",
+      "target-org"
+    ],
+    "plugin": "@salesforce/plugin-flow"
+  },
+  {
+    "alias": [],
+    "command": "flow:version:prune",
+    "flagAliases": [],
+    "flagChars": ["f", "o", "y"],
+    "flags": [
+      "all",
+      "api-version",
+      "dry-run",
+      "execute",
+      "flags-dir",
+      "flow",
+      "json",
+      "keep-latest",
+      "older-than",
+      "target-org",
+      "yes"
+    ],
+    "plugin": "@salesforce/plugin-flow"
   }
 ]
diff --git a/messages/flow.dependencies.md b/messages/flow.dependencies.md
new file mode 100644
index 0000000..effa496
--- /dev/null
+++ b/messages/flow.dependencies.md
@@ -0,0 +1,43 @@
+# summary
+
+Inspect direct Flow dependencies and references in a target org.
+
+# description
+
+Resolve the root Flow from --flow-name in --target-org, then read the selected version's metadata and extract its subflow references. Names, definition IDs, and version IDs are resolved from the org on every run; no fixture names or IDs are built into the command. Inspect additional candidate caller Flows when explicitly provided with --scan-flow. Also query MetadataComponentDependency for incoming and outgoing references to the root definition and selected version.
+
+--scan-flow is optional and repeatable. It defines which candidate caller Flows to inspect; it is not an automatic search for every caller in the org. Without it, the command still reads the root Flow and queries the dependency API, but incoming references can be incomplete.
+
+The default version policy is latest, including Draft versions. The active policy requires an active version for every selected Flow; it does not fall back silently. Flow names are DeveloperName values; use --namespace separately. The namespace applies to the root and explicitly selected scan Flows.
+
+This read-only command does not deploy, activate, execute, or delete metadata. It does not scan Apex source, resolve arbitrary runtime references, traverse dependencies recursively, generate a manifest, or claim a complete org-wide impact analysis. Empty dependency-API results do not mean no dependencies. Console output shows the root identity and incoming/outgoing relationships with their evidence. Use --json for structured results, including scan scope, dependency-API status, and coverage warnings.
+
+# examples
+
+- Inspect any Flow by its API DeveloperName in an authenticated org:
+
+  <%= config.bin %> <%= command.id %> --target-org my-org --flow-name MyFlowApiName
+
+- Also inspect two candidate caller Flows without changing the command implementation:
+
+  <%= config.bin %> <%= command.id %> --target-org my-org --flow-name MyFlowApiName --scan-flow FirstCaller --scan-flow SecondCaller
+
+- Select active versions in a namespace and return structured evidence and coverage information:
+
+  <%= config.bin %> <%= command.id %> --target-org my-org --namespace acme --flow-name MyFlowApiName --version-policy active --json
+
+# flags.flow-name.summary
+
+API DeveloperName of the root Flow (without a namespace prefix).
+
+# flags.namespace.summary
+
+Namespace of the root and scanned Flows; omit for unmanaged Flows.
+
+# flags.scan-flow.summary
+
+Additional caller Flow DeveloperName to inspect; repeat for more Flows (20 total including the root).
+
+# flags.version-policy.summary
+
+Select the latest or active version of each explicitly named Flow.
diff --git a/messages/flow.version.delete.md b/messages/flow.version.delete.md
new file mode 100644
index 0000000..95df1c1
--- /dev/null
+++ b/messages/flow.version.delete.md
@@ -0,0 +1,141 @@
+# summary
+
+Delete selected Flow versions normally, or force-delete one version with interactive confirmation.
+
+# description
+
+Select versions of one Flow by API DeveloperName and resolve exact version IDs in the target org. No Flow name, org or version ID is hardcoded. Use --namespace separately for namespaced Flows. API 67.0 or later is required for the existing deletion-assessment API.
+
+--versions accepts a single number, comma-separated numbers or inclusive ranges, for example 1,2,4-6, with at most 200 distinct selected versions. Every requested number receives a result. Missing, Active, and otherwise blocked versions do not reject the entire selection. No replacement version is chosen when an exact target disappears.
+
+--dry-run resolves the selection and calls POST /connect/interaction/flow-versions/deletion-assessment. It shows actual backend PASS, BLOCKED or ERROR results and missing-version errors without sending DELETE. A completed dry run exits 0, including blocked or errored items. A whole-request failure still returns an error. Preview is an observation, not a guarantee that a later deletion will succeed.
+
+For NORMAL execution, the SDK rechecks exact target identity and freshly assesses each version after confirmation. BLOCKED versions preserve the backend's complete reason and evidence and do not stop eligible siblings. Assessment ERROR is a failed item and does not authorize DELETE. Only PASS proceeds to DELETE /tooling/sobjects/Flow/{versionId}. A conclusive successful deletion reports SUCCEEDED; a conclusive delete rejection reports FAILED with the platform error. Each version is independent; earlier successes are not rolled back.
+
+The existing client preservation safeguard retains at least one version while the product decision about deleting the last remaining version is open. It applies per item and is explicitly identified as client policy, not an invented backend restriction. There is no blanket protection for the latest inactive version when another version remains. Client checks do not provide an atomic concurrency guarantee.
+
+Value options also accept bare name/value pairs: target-org my-org flow MyFlow versions 1,2,4-6. This is equivalent to --target-org my-org --flow MyFlow --versions 1,2,4-6, and both forms can be mixed. Supported bare names are target-org, flow, versions, namespace and api-version. Boolean options such as --dry-run, --yes and --json still require dashes. Duplicate value options and malformed arguments are rejected.
+
+Without --yes, NORMAL interactive execution displays the complete plan and waits 60 seconds for confirmation, defaulting to no. Timeout or Ctrl-C closes the prompt and cancels without deletion. Non-interactive and JSON NORMAL execution require --yes. --dry-run never requires confirmation. Confirmation covers the exact selected targets, not arbitrary org changes. FORCE uses the separate typed confirmation described below.
+
+JSON contract 2 contains the assessed plan and per-version execution results, including the source of a reason. Exit 0 means all requested deletions succeeded or a dry run completed. Exit 1 means execution had blocked items and no failed or uncertain items. Exit 2 means any item failed, has an unconfirmed deletion outcome, or was not attempted after execution stopped. Cancellation exits 0.
+
+Transport retries and redirects are disabled for DELETE. Native authentication refresh remains in the Salesforce SDK. A timeout, lost response or inconclusive server error is reported as UNKNOWN with targetDeleted null; remaining versions are NOT_ATTEMPTED. These exceptional results must not be relabeled as confirmed failures, retried automatically, or treated as rollback. Org changes stop further execution. Normal deletion does not abandon interviews or remove references.
+
+--force selects the separate C6 backend and accepts exactly one version number, with no commas or ranges. It never adds a force flag to Tooling DELETE. It requires both input and output terminals to be interactive, including --force --dry-run. The backend preview supplies eligibility and impact. A blocked preview never executes. --dry-run displays the force preview without prompting or deleting; a completed preview exits 0.
+
+Force execution always displays the impact and requires typing the exact Flow API name and version number into two empty prompts. --yes is ignored in force mode and cannot bypass either prompt. Timeout, Ctrl-C or a mismatch cancels. The confirmation window is normally two minutes and never shorter than one minute; an expiring preview requires a fresh command. JSON force execution also requires an interactive stderr: the human preview and prompts go to stderr, and the final JSON stays on stdout. Redirected input/output and CI execution are rejected.
+
+Force preview calls POST /connect/interaction/flow-versions/force-delete/preview with exact version and definition IDs. Execution sends only the private, single-use confirmation token to POST /connect/interaction/flow-versions/force-delete. Typed text and CLI flags are not sent to the backend. Tokens are never included in console/JSON reports. A stale or rejected token requires a fresh preview and typed confirmation; it is not automatically retried. A lost or inconclusive execution response is UNKNOWN and requires reconciliation before another attempt.
+
+Force JSON uses mode FORCE and contract 1, documented in schemas/flow-version-force-delete.json. Normal mode retains contract 2 in schemas/flow-version-delete.json. Force execution exits 0 for success or cancellation, 1 for blocked, and 2 for failed or uncertain. Force execution requires a backend that enforces the dedicated Force Delete Flow Versions permission, org-level disable, token authorization, audit and runtime cleanup. CLI interactivity does not replace backend authorization.
+
+# examples
+
+- Assess a mixed selection without deleting anything:
+
+  <%= config.bin %> <%= command.id %> --target-org my-org --flow MyFlow --versions 1,2,4-6 --dry-run
+
+- Select versions and confirm interactively:
+
+  <%= config.bin %> <%= command.id %> --target-org my-org --flow MyFlow --versions 1-3
+
+- Use equivalent bare name/value pairs:
+
+  <%= config.bin %> <%= command.id %> target-org my-org flow MyFlow versions 1-3
+
+- Approve the exact selection and return JSON:
+
+  <%= config.bin %> <%= command.id %> --target-org my-org --flow MyFlow --versions 1-3 --yes --json
+
+- Preview force-deletion impact for one version from an interactive terminal:
+
+  <%= config.bin %> <%= command.id %> --target-org my-org --flow MyFlow --versions 2 --force --dry-run
+
+- Review force-deletion impact and type the Flow name and version to confirm:
+
+  <%= config.bin %> <%= command.id %> --target-org my-org --flow MyFlow --versions 2 --force
+
+# flags.flow.summary
+
+API DeveloperName of the Flow, without its namespace prefix.
+
+# flags.versions.summary
+
+Explicit version numbers or inclusive ranges, for example 1,2,4-6. With --force, exactly one version number is required.
+
+# flags.namespace.summary
+
+Namespace of the Flow; omit for an unmanaged Flow.
+
+# flags.dry-run.summary
+
+Preview the selected normal or force deletion without mutating the org.
+
+# flags.yes.summary
+
+Approve normal deletion without prompting; ignored by --force, which always requires typed confirmation.
+
+# flags.force.summary
+
+Force-delete one version using an interactive impact preview and typed Flow name/version confirmation.
+
+# confirmationRequired
+
+Non-interactive or JSON deletion requires --yes. Use --dry-run first to inspect the assessed selection.
+
+# confirmDelete
+
+Process deletion for these %s requested Flow versions from %s? You have 60 seconds to respond; no response cancels deletion. Every target is reassessed before deletion and each version has its own result.
+
+# cancelled
+
+Deletion cancelled. No deletion requests were sent.
+
+# dryRunNotice
+
+Dry run only. No deletion requests were sent. Assessment reflects current state; execution reassesses each exact target.
+
+# forceSingleVersion
+
+Force deletion accepts exactly one positive version number, for example --versions 2. Commas and ranges are not allowed.
+
+# forceInteractiveRequired
+
+Force deletion requires interactive input and output terminals, including dry run. JSON execution also requires interactive stderr for its impact preview and typed prompts. --yes cannot bypass this requirement.
+
+# forceIrreversible
+
+Force deletion abandons the affected saved interviews and deletes this Flow version. Abandonment deletes their saved data; those interviews cannot be resumed or retried. This action cannot be undone.
+
+# forceNoMutation
+
+No force-delete execution request has been sent.
+
+# forceUnknown
+
+The force-delete outcome is unconfirmed. Reconcile this exact Flow version and its interviews before another attempt. No automatic retry was sent.
+
+# forcePreviewExpiring
+
+The force preview has less than one minute remaining or its expiry is unavailable. Nothing was executed. Run a fresh preview and complete typed confirmation; an expired token is never refreshed automatically.
+
+# forceYesIgnored
+
+--yes is ignored for force deletion. You must type the exact Flow API name and version number below.
+
+# forceInvalidPreview
+
+The force preview does not identify the exact Flow name and version required for confirmation. Nothing was executed.
+
+# forceConfirmFlow
+
+Type the exact Flow API name (%s)
+
+# forceConfirmVersion
+
+Type the exact version number (%s)
+
+# forceCancelled
+
+Force deletion cancelled. No force-delete execution request was sent.
diff --git a/messages/flow.version.list.md b/messages/flow.version.list.md
new file mode 100644
index 0000000..c68e227
--- /dev/null
+++ b/messages/flow.version.list.md
@@ -0,0 +1,77 @@
+# summary
+
+List Flow versions, reference and interview counts, and deletion eligibility.
+
+# description
+
+Read Flow versions through the authenticated Core Connect list API. Choose exactly one scope: --flow for an exact Flow API name, including its namespace prefix when applicable, or --all for every Flow in the org. No Flow name, org, count or version limit is hardcoded. The Core list contract has no separate namespace filter; --namespace is rejected. Use a qualified --flow name instead.
+
+The console includes the A3/C1 fields: Flow version name, version number, status, age, creator, creation date, last-modified date, reference count, paused and failed interview counts, and whether the version is deletable, with the full server reason when it is not. Standard Salesforce CLI tables wrap complete values. Normal-width consoles use Field/Value tables. JSON preserves raw IDs and server values.
+
+API 67.0 or later and POST /connect/interaction/flow-versions/list are required. HTTP 201 is success even when versions are BLOCKED or ERROR. The SDK follows every nextOffset, including empty pages. This command does not query Tooling inventory or the separate deletion-assessment API.
+
+Native status filters are case-insensitive: active, draft, obsolete, invaliddraft and underreview. Inactive is a compatibility alias: the SDK retrieves list pages without a server status filter, then displays non-Active rows. ERROR rows with unavailable status remain visible. --older-than accepts whole days from CreatedDate, from 0d to 36500d. --deletable requests PASS rows; the server also retains ERROR rows. --min-percent uses the Flow's complete version count before filtering and actual org version limit. The CLI preserves the server's integer percentage. A zero limit and null percentage remain explicit; its product filtering rule is still open.
+
+PASS displays Deletable Yes. BLOCKED displays No and the complete backend message. ERROR displays Error: that version was not fully assessed. The CLI does not create local blockers or replace unavailable metadata/counts with zero. All three counts come directly from the list response. The reference-count counting unit remains subject to product-owner confirmation.
+
+JSON now follows Core contractVersion 1 with grouped flows and direct per-version counts, deletable, outcome, reasonCode and message. It replaces obsolete client format 6 and its flat rows and repeated error arrays. returnedVersionCount is the displayed aggregate. candidateVersionCount is the server's candidate/prefix metric, not a complete org total. A server listTruncated flag or any per-version ERROR produces exit status 1 after the report is returned. BLOCKED alone leaves status 0. A failed or malformed whole request returns a typed error instead of fabricated inventory.
+
+No Flow, interview, reference or business record is modified. This command never calls Tooling DELETE and requires no confirmation. A later deletion still runs current backend validation.
+
+# examples
+
+- List versions of one Flow:
+
+  <%= config.bin %> <%= command.id %> --target-org my-org --flow MyFlow
+
+- List versions of a namespaced Flow using its qualified API name:
+
+  <%= config.bin %> <%= command.id %> --target-org my-org --flow billing__MyFlow
+
+- Find Flows using at least 80 percent of their configured version limit:
+
+  <%= config.bin %> <%= command.id %> --target-org my-org --all --min-percent 80
+
+- Return backend PASS versions and any assessment errors as JSON:
+
+  <%= config.bin %> <%= command.id %> --target-org my-org --flow MyFlow --deletable --json
+
+- Return older inactive versions as JSON:
+
+  <%= config.bin %> <%= command.id %> --target-org my-org --flow MyFlow --status inactive --older-than 90d --json
+
+# flags.flow.summary
+
+Exact Flow API name, qualified with its namespace when applicable; mutually exclusive with --all.
+
+# flags.all.summary
+
+List versions for all Flows in the org; mutually exclusive with --flow.
+
+# flags.namespace.summary
+
+Unsupported by the Core list API; use --flow with the qualified API name instead.
+
+# flags.status.summary
+
+Filter by active, inactive (all non-Active), draft, obsolete, invaliddraft or underreview; case-insensitive.
+
+# flags.older-than.summary
+
+Show versions at least this many whole days old since CreatedDate, from 0d to 36500d.
+
+# flags.min-percent.summary
+
+Show Flows at or above this percentage of their configured version limit (0-100).
+
+# flags.deletable.summary
+
+Show backend PASS versions; the server retains assessment errors.
+
+# scopeRequired
+
+Choose exactly one scope: --flow <Flow API name> or --all.
+
+# invalidMinPercent
+
+--min-percent must be an integer from 0 to 100.
diff --git a/messages/flow.version.prune.md b/messages/flow.version.prune.md
new file mode 100644
index 0000000..6caf770
--- /dev/null
+++ b/messages/flow.version.prune.md
@@ -0,0 +1,79 @@
+# summary
+
+Preview or execute retention cleanup for one Flow or all Flows in an org.
+
+# description
+
+Defaults to a preview. Core's C1 list is paged in full, without status, age or deletable filters, before the CLI applies the retention policy. No new backend endpoint is required. Use API 67.0 or later and a Core server that returns statusChangeDate. A server omitting that field produces an actionable error rather than guessing a rollback version.
+
+Keep the Active version, the latest N by version number (default 5), and the Obsolete version with the newest statusChangeDate. A null timestamp never wins over a real timestamp. As a conservative interim rule, keep every version tied at the newest timestamp; when all Obsolete timestamps are null, keep all Obsolete versions. Packaging can stamp statusChangeDate, so this rule is not proof of the historical previous activation. Do not substitute lastModifiedDate for activation history. This interim rule is distinct from the production B1 rule, which uses Last Modified Date and protects Active plus the latest N. The client will adopt shared B1 selection after its contract is agreed.
+
+Only inactive versions outside those protections, old enough according to Core's ageDays (default at least 90 UTC days), and marked PASS/deletable by Core are candidates. ERROR is not deletable. Incomplete catalogs or missing required policy metadata do not authorize deletion.
+
+Use --execute for an interactive confirmation, which defaults to no and allows 60 seconds. Use --yes to explicitly authorize non-interactive execution. These options and --dry-run are mutually exclusive. JSON/non-interactive execution requires --yes. Without either execution option, nothing is deleted, even in an interactive terminal.
+
+Execution preserves the exact previewed version IDs. Each candidate goes through the existing C2 normal-delete service: current identity, fresh deletion assessment, a fresh complete C1 retention check, and then Tooling DELETE only if still eligible. Known blocked and failed items do not stop eligible siblings. An unconfirmed deletion outcome or org-context change stops later mutations. Client checks cannot atomically reserve retention state against other writers. No force deletion, reference removal or interview abandonment is performed.
+
+JSON contract 1 includes the policy, every kept/candidate/blocked/error row with reasons, and execution results. A completed preview or cancellation exits 0. Execution exits 1 for blocked items and 2 for failed, unassessed or uncertain items. A whole-request failure is an error.
+
+# examples
+
+- Preview one Flow using the default keep count and age:
+
+  <%= config.bin %> <%= command.id %> --target-org my-org --flow MyFlow
+
+- Preview an explicit retention rule:
+
+  <%= config.bin %> <%= command.id %> --target-org my-org --flow MyFlow --keep-latest 5 --older-than 90d --dry-run
+
+- Review and confirm interactively:
+
+  <%= config.bin %> <%= command.id %> --target-org my-org --flow MyFlow --execute
+
+- Explicitly authorize org-wide cleanup and return JSON:
+
+  <%= config.bin %> <%= command.id %> --target-org my-org --all --keep-latest 5 --older-than 90d --yes --json
+
+# flags.flow.summary
+
+Fully qualified Flow API name; choose --flow or --all.
+
+# flags.all.summary
+
+Evaluate every Flow in the org, after paging the complete C1 catalog.
+
+# flags.keep-latest.summary
+
+Number of latest versions to keep by version number (at least 1; default 5).
+
+# flags.older-than.summary
+
+Minimum age in UTC days, such as 90d (inclusive; default 90d).
+
+# flags.dry-run.summary
+
+Explicitly preview the retention plan without deletion; preview is the default.
+
+# flags.execute.summary
+
+Display the exact plan and request interactive confirmation before deletion.
+
+# flags.yes.summary
+
+Explicitly authorize deletion of the planned cleanup candidates without prompting.
+
+# scopeRequired
+
+Choose exactly one scope: --flow <API name> or --all.
+
+# confirmationRequired
+
+Non-interactive or JSON cleanup requires --yes. Omit execution options to preview first.
+
+# confirmPrune
+
+Delete these %s cleanup candidates from %s? Deletion cannot be undone. You have 60 seconds to respond; no response cancels. Each exact version is reassessed before deletion.
+
+# cancelled
+
+Cleanup cancelled. No deletion requests were sent.
diff --git a/package.json b/package.json
index 6985c22..79fcbb8 100644
--- a/package.json
+++ b/package.json
@@ -1,11 +1,14 @@
 {
   "name": "@salesforce/plugin-flow",
-  "description": "Plugin for testing flows",
+  "description": "Salesforce CLI commands for Flow testing, dependency analysis, and version management",
   "version": "2.0.2",
   "dependencies": {
+    "@inquirer/confirm": "^6.1.1",
+    "@inquirer/input": "^5.1.9",
     "@oclif/core": "^5.0.0",
     "@salesforce/apex-node": "^9.0.7",
     "@salesforce/core": "^9.1.9",
+    "@salesforce/flow-node": "git+https://github.com/forcedotcom/flows.git#98a0fe5a2611d20cf62c589388b3f887394162f4",
     "@salesforce/kit": "^4.0.0",
     "@salesforce/sf-plugins-core": "^13.0.4",
     "ansis": "^3.17.0"
@@ -20,6 +23,7 @@
     "@types/mocha": "^10.0.10",
     "@types/node": "^18",
     "@types/sinon": "^10.0.20",
+    "ajv": "^6.12.6",
     "eslint": "^10.4.0",
     "eslint-config-salesforce-typescript": "^6.0.0",
     "eslint-plugin-sf-plugin": "^3.0.1",
@@ -60,13 +64,16 @@
     ],
     "topics": {
       "flow": {
-        "description": "Commands for testing flows",
+        "description": "Commands for testing flows and managing Flow dependencies and versions",
         "subtopics": {
           "run": {
             "description": "Running flow tests"
           },
           "get": {
             "description": "Getting flow test results"
+          },
+          "version": {
+            "description": "Manage Flow versions"
           }
         }
       }
@@ -107,7 +114,9 @@
       "files": [
         "src/**/*.ts",
         "**/tsconfig.json",
-        "messages/**"
+        "messages/**",
+        "package.json",
+        "yarn.lock"
       ],
       "output": [
         "lib/**",
@@ -160,13 +169,19 @@
       },
       "files": [
         "test/**/*.ts",
+        "test/**/*.mjs",
         "src/**/*.ts",
         "**/tsconfig.json",
         ".mocha*",
         "!*.nut.ts",
-        ".nycrc"
+        ".nycrc",
+        "package.json",
+        "yarn.lock"
       ],
-      "output": []
+      "output": [],
+      "dependencies": [
+        "compile"
+      ]
     },
     "test:command-reference": {
       "command": "node --loader ts-node/esm --no-warnings=ExperimentalWarning \"./bin/dev.js\" commandreference:generate --erroronwarnings",
diff --git a/schemas/flow-version-delete.json b/schemas/flow-version-delete.json
new file mode 100644
index 0000000..e08fce8
--- /dev/null
+++ b/schemas/flow-version-delete.json
@@ -0,0 +1,463 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "FlowVersionDeleteCommandReport",
+  "description": "C2 independent Flow version deletion with actual backend assessments and exact targets.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "contractVersion",
+    "mode",
+    "targetOrg",
+    "apiVersion",
+    "dryRun",
+    "confirmed",
+    "outcome",
+    "plan",
+    "deletion"
+  ],
+  "properties": {
+    "contractVersion": {
+      "const": "2"
+    },
+    "mode": {
+      "const": "NORMAL"
+    },
+    "targetOrg": {
+      "type": "string"
+    },
+    "apiVersion": {
+      "type": "string"
+    },
+    "dryRun": {
+      "type": "boolean"
+    },
+    "confirmed": {
+      "type": "boolean"
+    },
+    "outcome": {
+      "enum": ["PREVIEWED", "CANCELLED", "SUCCEEDED", "FAILED", "PARTIAL", "UNKNOWN"]
+    },
+    "plan": {
+      "$ref": "#/definitions/Plan"
+    },
+    "deletion": {
+      "anyOf": [
+        {
+          "$ref": "#/definitions/Execution"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    }
+  },
+  "definitions": {
+    "Error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["code", "message"],
+      "properties": {
+        "code": {
+          "type": "string"
+        },
+        "message": {
+          "type": "string"
+        }
+      }
+    },
+    "Evidence": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "sourceId",
+        "sourceType",
+        "sourceName",
+        "targetKind",
+        "targetId",
+        "targetName",
+        "channels",
+        "interviewRoles",
+        "detailsRedacted"
+      ],
+      "properties": {
+        "sourceId": {
+          "type": "string",
+          "pattern": "^[A-Za-z0-9]{18}$"
+        },
+        "sourceType": {
+          "type": "string"
+        },
+        "sourceName": {
+          "type": ["string", "null"]
+        },
+        "targetKind": {
+          "enum": ["VERSION", "OWNED_RESOURCE"]
+        },
+        "targetId": {
+          "type": "string",
+          "pattern": "^[A-Za-z0-9]{18}$"
+        },
+        "targetName": {
+          "type": ["string", "null"]
+        },
+        "channels": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "interviewRoles": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "detailsRedacted": {
+          "type": "boolean"
+        }
+      }
+    },
+    "Assessment": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["versionId", "outcome", "reasonCode", "message", "evidence"],
+      "properties": {
+        "versionId": {
+          "type": "string",
+          "pattern": "^301[A-Za-z0-9]{15}$"
+        },
+        "outcome": {
+          "enum": ["PASS", "BLOCKED", "ERROR"]
+        },
+        "reasonCode": {
+          "type": ["string", "null"]
+        },
+        "message": {
+          "type": ["string", "null"]
+        },
+        "evidence": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Evidence"
+          }
+        },
+        "counts": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["referenceCount", "pausedInterviewCount", "failedInterviewCount"],
+          "properties": {
+            "referenceCount": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "pausedInterviewCount": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "failedInterviewCount": {
+              "type": "integer",
+              "minimum": 0
+            }
+          }
+        },
+        "versionLimit": {
+          "type": "integer",
+          "minimum": 0
+        }
+      }
+    },
+    "Target": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "definitionId",
+        "versionId",
+        "flowName",
+        "namespace",
+        "versionNumber",
+        "status",
+        "assessment",
+        "error"
+      ],
+      "properties": {
+        "definitionId": {
+          "type": "string",
+          "pattern": "^300[A-Za-z0-9]{15}$"
+        },
+        "versionId": {
+          "anyOf": [
+            {
+              "type": "string",
+              "pattern": "^301[A-Za-z0-9]{15}$"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "flowName": {
+          "type": "string"
+        },
+        "namespace": {
+          "type": ["string", "null"]
+        },
+        "versionNumber": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "status": {
+          "type": ["string", "null"]
+        },
+        "assessment": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/Assessment"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "error": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/Error"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      }
+    },
+    "Result": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "definitionId",
+        "versionId",
+        "flowName",
+        "namespace",
+        "versionNumber",
+        "status",
+        "assessment",
+        "error",
+        "state",
+        "targetDeleted",
+        "source"
+      ],
+      "properties": {
+        "definitionId": {
+          "type": "string",
+          "pattern": "^300[A-Za-z0-9]{15}$"
+        },
+        "versionId": {
+          "anyOf": [
+            {
+              "type": "string",
+              "pattern": "^301[A-Za-z0-9]{15}$"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "flowName": {
+          "type": "string"
+        },
+        "namespace": {
+          "type": ["string", "null"]
+        },
+        "versionNumber": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "status": {
+          "type": ["string", "null"]
+        },
+        "assessment": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/Assessment"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "error": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/Error"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "state": {
+          "enum": ["SUCCEEDED", "BLOCKED", "FAILED", "UNKNOWN", "NOT_ATTEMPTED"]
+        },
+        "targetDeleted": {
+          "type": ["boolean", "null"]
+        },
+        "source": {
+          "enum": ["ASSESSMENT", "TOOLING", "CLIENT_POLICY", "RESOLUTION", "SAFETY"]
+        }
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "state": {
+                "const": "SUCCEEDED"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "targetDeleted": {
+                "const": true
+              },
+              "error": {
+                "type": "null"
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "state": {
+                "enum": ["UNKNOWN", "NOT_ATTEMPTED"]
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "targetDeleted": {
+                "type": "null"
+              }
+            }
+          }
+        }
+      ]
+    },
+    "Plan": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "contractVersion",
+        "orgId",
+        "flowName",
+        "namespace",
+        "definitionId",
+        "warnings",
+        "requestedVersions",
+        "versions",
+        "availableVersionCount"
+      ],
+      "properties": {
+        "contractVersion": {
+          "const": "2"
+        },
+        "orgId": {
+          "type": "string",
+          "pattern": "^00D[A-Za-z0-9]{15}$"
+        },
+        "flowName": {
+          "type": "string"
+        },
+        "namespace": {
+          "type": ["string", "null"]
+        },
+        "definitionId": {
+          "type": "string",
+          "pattern": "^300[A-Za-z0-9]{15}$"
+        },
+        "warnings": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "requestedVersions": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 200,
+          "uniqueItems": true,
+          "items": {
+            "type": "integer",
+            "minimum": 1
+          }
+        },
+        "versions": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 200,
+          "items": {
+            "$ref": "#/definitions/Target"
+          }
+        },
+        "availableVersionCount": {
+          "type": "integer",
+          "minimum": 1
+        }
+      }
+    },
+    "Execution": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "contractVersion",
+        "orgId",
+        "flowName",
+        "namespace",
+        "definitionId",
+        "warnings",
+        "mode",
+        "outcome",
+        "results"
+      ],
+      "properties": {
+        "contractVersion": {
+          "const": "2"
+        },
+        "orgId": {
+          "type": "string",
+          "pattern": "^00D[A-Za-z0-9]{15}$"
+        },
+        "flowName": {
+          "type": "string"
+        },
+        "namespace": {
+          "type": ["string", "null"]
+        },
+        "definitionId": {
+          "type": "string",
+          "pattern": "^300[A-Za-z0-9]{15}$"
+        },
+        "warnings": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "mode": {
+          "const": "NORMAL"
+        },
+        "outcome": {
+          "enum": ["SUCCEEDED", "FAILED", "PARTIAL", "UNKNOWN"]
+        },
+        "results": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 200,
+          "items": {
+            "$ref": "#/definitions/Result"
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/schemas/flow-version-force-delete.json b/schemas/flow-version-force-delete.json
new file mode 100644
index 0000000..f3e92b1
--- /dev/null
+++ b/schemas/flow-version-force-delete.json
@@ -0,0 +1,513 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "FlowVersionForceDeleteCommandReport",
+  "description": "C6 manual one-version force deletion. Private confirmation tokens and typed answers are never part of this report. NORMAL mode remains contract 2 in flow-version-delete.json.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "contractVersion",
+    "mode",
+    "targetOrg",
+    "apiVersion",
+    "dryRun",
+    "confirmed",
+    "confirmationMethod",
+    "outcome",
+    "plan",
+    "deletion"
+  ],
+  "properties": {
+    "contractVersion": {
+      "const": "1"
+    },
+    "mode": {
+      "const": "FORCE"
+    },
+    "targetOrg": {
+      "type": "string"
+    },
+    "apiVersion": {
+      "type": "string"
+    },
+    "dryRun": {
+      "type": "boolean"
+    },
+    "confirmed": {
+      "type": "boolean"
+    },
+    "confirmationMethod": {
+      "enum": ["TYPED_FLOW_AND_VERSION", null]
+    },
+    "outcome": {
+      "enum": ["PREVIEWED", "CANCELLED", "SUCCEEDED", "BLOCKED", "FAILED", "UNKNOWN"]
+    },
+    "plan": {
+      "$ref": "#/definitions/Plan"
+    },
+    "deletion": {
+      "anyOf": [
+        {
+          "$ref": "#/definitions/Result"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    }
+  },
+  "definitions": {
+    "Error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["code", "message"],
+      "properties": {
+        "code": {
+          "type": "string",
+          "minLength": 1
+        },
+        "message": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    },
+    "Impact": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "flowApiName",
+        "versionNumber",
+        "eligible",
+        "reasonCode",
+        "pausedInterviewCount",
+        "failedInterviewCount",
+        "otherInterviewCount",
+        "distinctUserCount",
+        "oldestInterviewAgeDays",
+        "orchestrationInProgressCount",
+        "referencingVersionCount",
+        "scheduledResumeWithin7Days",
+        "workItemCount"
+      ],
+      "properties": {
+        "flowApiName": {
+          "type": ["string", "null"]
+        },
+        "versionNumber": {
+          "type": ["integer", "null"],
+          "minimum": 1
+        },
+        "eligible": {
+          "type": "boolean"
+        },
+        "reasonCode": {
+          "type": ["string", "null"]
+        },
+        "pausedInterviewCount": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "failedInterviewCount": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "otherInterviewCount": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "distinctUserCount": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "oldestInterviewAgeDays": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "orchestrationInProgressCount": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "referencingVersionCount": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "scheduledResumeWithin7Days": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "workItemCount": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        }
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "eligible": {
+                "const": true
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "flowApiName": {
+                "type": "string",
+                "pattern": "^[A-Za-z][A-Za-z0-9_]{0,254}$"
+              },
+              "versionNumber": {
+                "type": "integer",
+                "minimum": 1
+              },
+              "reasonCode": {
+                "type": "null"
+              },
+              "pausedInterviewCount": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "failedInterviewCount": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "otherInterviewCount": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "distinctUserCount": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "orchestrationInProgressCount": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "referencingVersionCount": {
+                "type": "integer",
+                "minimum": 0
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "eligible": {
+                "const": false
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "reasonCode": {
+                "type": "string",
+                "minLength": 1
+              }
+            }
+          }
+        }
+      ]
+    },
+    "Plan": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "contractVersion",
+        "orgId",
+        "definitionId",
+        "versionId",
+        "flowName",
+        "namespace",
+        "versionNumber",
+        "availableVersionCount",
+        "impact",
+        "expiresAt",
+        "clientPolicyError"
+      ],
+      "properties": {
+        "contractVersion": {
+          "const": "1"
+        },
+        "orgId": {
+          "type": "string",
+          "pattern": "^00D[A-Za-z0-9]{15}$"
+        },
+        "definitionId": {
+          "type": "string",
+          "pattern": "^300[A-Za-z0-9]{15}$"
+        },
+        "versionId": {
+          "type": "string",
+          "pattern": "^301[A-Za-z0-9]{15}$"
+        },
+        "flowName": {
+          "type": "string",
+          "minLength": 1
+        },
+        "namespace": {
+          "type": ["string", "null"]
+        },
+        "versionNumber": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "availableVersionCount": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "impact": {
+          "$ref": "#/definitions/Impact"
+        },
+        "expiresAt": {
+          "type": ["string", "null"],
+          "format": "date-time"
+        },
+        "clientPolicyError": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/Error"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      }
+    },
+    "Result": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "contractVersion",
+        "mode",
+        "orgId",
+        "definitionId",
+        "versionId",
+        "flowName",
+        "namespace",
+        "versionNumber",
+        "state",
+        "source",
+        "targetDeleted",
+        "abandonedInterviewCount",
+        "error"
+      ],
+      "properties": {
+        "contractVersion": {
+          "const": "1"
+        },
+        "mode": {
+          "const": "FORCE"
+        },
+        "orgId": {
+          "type": "string",
+          "pattern": "^00D[A-Za-z0-9]{15}$"
+        },
+        "definitionId": {
+          "type": "string",
+          "pattern": "^300[A-Za-z0-9]{15}$"
+        },
+        "versionId": {
+          "type": "string",
+          "pattern": "^301[A-Za-z0-9]{15}$"
+        },
+        "flowName": {
+          "type": "string",
+          "minLength": 1
+        },
+        "namespace": {
+          "type": ["string", "null"]
+        },
+        "versionNumber": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "state": {
+          "enum": ["SUCCEEDED", "BLOCKED", "FAILED", "UNKNOWN"]
+        },
+        "source": {
+          "enum": ["BACKEND", "CLIENT_POLICY", "SAFETY"]
+        },
+        "targetDeleted": {
+          "type": ["boolean", "null"]
+        },
+        "abandonedInterviewCount": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "error": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/Error"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "state": {
+                "const": "SUCCEEDED"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "targetDeleted": {
+                "const": true
+              },
+              "error": {
+                "type": "null"
+              },
+              "abandonedInterviewCount": {
+                "type": "integer",
+                "minimum": 0
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "state": {
+                "const": "UNKNOWN"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "targetDeleted": {
+                "type": "null"
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "state": {
+                "enum": ["BLOCKED", "FAILED"]
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "targetDeleted": {
+                "const": false
+              }
+            }
+          }
+        }
+      ]
+    }
+  },
+  "allOf": [
+    {
+      "if": {
+        "properties": {
+          "dryRun": {
+            "const": true
+          }
+        }
+      },
+      "then": {
+        "properties": {
+          "confirmed": {
+            "const": false
+          },
+          "confirmationMethod": {
+            "type": "null"
+          },
+          "outcome": {
+            "const": "PREVIEWED"
+          },
+          "deletion": {
+            "type": "null"
+          }
+        }
+      }
+    },
+    {
+      "if": {
+        "properties": {
+          "confirmed": {
+            "const": false
+          }
+        }
+      },
+      "then": {
+        "properties": {
+          "confirmationMethod": {
+            "type": "null"
+          },
+          "deletion": {
+            "type": "null"
+          }
+        }
+      }
+    },
+    {
+      "if": {
+        "properties": {
+          "confirmed": {
+            "const": true
+          }
+        }
+      },
+      "then": {
+        "properties": {
+          "confirmationMethod": {
+            "const": "TYPED_FLOW_AND_VERSION"
+          }
+        }
+      }
+    },
+    {
+      "if": {
+        "properties": {
+          "outcome": {
+            "enum": ["PREVIEWED", "CANCELLED"]
+          }
+        }
+      },
+      "then": {
+        "properties": {
+          "confirmed": {
+            "const": false
+          },
+          "deletion": {
+            "type": "null"
+          }
+        }
+      }
+    },
+    {
+      "if": {
+        "properties": {
+          "outcome": {
+            "const": "SUCCEEDED"
+          }
+        }
+      },
+      "then": {
+        "properties": {
+          "confirmed": {
+            "const": true
+          },
+          "deletion": {
+            "type": "object",
+            "properties": {
+              "state": {
+                "const": "SUCCEEDED"
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}
diff --git a/schemas/flow-version-list.json b/schemas/flow-version-list.json
new file mode 100644
index 0000000..bddc274
--- /dev/null
+++ b/schemas/flow-version-list.json
@@ -0,0 +1,343 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "FlowVersionListCommandReport",
+  "description": "C1 version list from the Core Connect list contract, with authenticated CLI scope metadata. Counts, limits and outcomes are server values.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "contractVersion",
+    "orgId",
+    "generatedAt",
+    "targetOrg",
+    "apiVersion",
+    "scope",
+    "filters",
+    "versionLimit",
+    "returnedVersionCount",
+    "candidateVersionCount",
+    "listTruncated",
+    "catalogComplete",
+    "nextOffset",
+    "flows"
+  ],
+  "properties": {
+    "contractVersion": {
+      "const": "1"
+    },
+    "orgId": {
+      "type": "string",
+      "pattern": "^00D[A-Za-z0-9]{15}$"
+    },
+    "generatedAt": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "targetOrg": {
+      "type": "string"
+    },
+    "apiVersion": {
+      "type": "string"
+    },
+    "scope": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["all", "flowName", "namespace", "allNamespaces"],
+      "properties": {
+        "all": {
+          "type": "boolean"
+        },
+        "flowName": {
+          "type": ["string", "null"]
+        },
+        "namespace": {
+          "type": "null"
+        },
+        "allNamespaces": {
+          "type": "boolean"
+        }
+      }
+    },
+    "filters": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["status", "olderThan", "minPercent", "deletable"],
+      "properties": {
+        "status": {
+          "type": ["string", "null"]
+        },
+        "olderThan": {
+          "type": ["string", "null"]
+        },
+        "minPercent": {
+          "type": ["integer", "null"],
+          "minimum": 0,
+          "maximum": 100
+        },
+        "deletable": {
+          "type": "boolean"
+        }
+      }
+    },
+    "versionLimit": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "returnedVersionCount": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "candidateVersionCount": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "listTruncated": {
+      "type": "boolean"
+    },
+    "catalogComplete": {
+      "type": "boolean",
+      "description": "True only for an unfiltered, fully paged catalog whose terminal page and whole-Flow counts prove completeness."
+    },
+    "nextOffset": {
+      "type": "null"
+    },
+    "flows": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/Flow"
+      }
+    }
+  },
+  "definitions": {
+    "Version": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "versionId",
+        "versionNumber",
+        "versionName",
+        "status",
+        "createdDate",
+        "ageDays",
+        "createdById",
+        "createdByName",
+        "lastModifiedDate",
+        "referenceCount",
+        "pausedInterviewCount",
+        "failedInterviewCount",
+        "deletable",
+        "outcome",
+        "reasonCode",
+        "message"
+      ],
+      "properties": {
+        "versionId": {
+          "type": "string",
+          "pattern": "^301[A-Za-z0-9]{15}$"
+        },
+        "versionNumber": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "versionName": {
+          "type": ["string", "null"]
+        },
+        "status": {
+          "type": ["string", "null"]
+        },
+        "createdDate": {
+          "type": ["string", "null"],
+          "format": "date-time"
+        },
+        "ageDays": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "createdById": {
+          "anyOf": [
+            {
+              "type": "string",
+              "pattern": "^005[A-Za-z0-9]{15}$"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "createdByName": {
+          "type": ["string", "null"]
+        },
+        "lastModifiedDate": {
+          "type": ["string", "null"],
+          "format": "date-time"
+        },
+        "statusChangeDate": {
+          "type": ["string", "null"],
+          "format": "date-time",
+          "description": "Stored UTC status-change timestamp; null means no stored value. Omitted by older Core builds."
+        },
+        "referenceCount": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "pausedInterviewCount": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "failedInterviewCount": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "deletable": {
+          "type": "boolean"
+        },
+        "outcome": {
+          "enum": ["PASS", "BLOCKED", "ERROR"]
+        },
+        "reasonCode": {
+          "type": ["string", "null"]
+        },
+        "message": {
+          "type": ["string", "null"]
+        }
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "outcome": {
+                "const": "PASS"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "deletable": {
+                "const": true
+              },
+              "reasonCode": {
+                "type": "null"
+              },
+              "message": {
+                "type": "null"
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "outcome": {
+                "enum": ["BLOCKED", "ERROR"]
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "deletable": {
+                "const": false
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "outcome": {
+                "enum": ["PASS", "BLOCKED"]
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "referenceCount": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "pausedInterviewCount": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "failedInterviewCount": {
+                "type": "integer",
+                "minimum": 0
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "outcome": {
+                "const": "BLOCKED"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "message": {
+                "type": "string",
+                "minLength": 1
+              }
+            }
+          }
+        }
+      ]
+    },
+    "Flow": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["definitionId", "apiName", "label", "versionCount", "limitPercent", "versions"],
+      "properties": {
+        "definitionId": {
+          "type": "string",
+          "pattern": "^300[A-Za-z0-9]{15}$"
+        },
+        "apiName": {
+          "type": "string",
+          "minLength": 1
+        },
+        "label": {
+          "type": ["string", "null"]
+        },
+        "versionCount": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "limitPercent": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "versions": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Version"
+          }
+        }
+      }
+    }
+  },
+  "allOf": [
+    {
+      "if": {
+        "properties": {
+          "versionLimit": {
+            "const": 0
+          }
+        }
+      },
+      "then": {
+        "properties": {
+          "flows": {
+            "items": {
+              "properties": {
+                "limitPercent": {
+                  "type": "null"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}
diff --git a/schemas/flow-version-prune.json b/schemas/flow-version-prune.json
new file mode 100644
index 0000000..144f479
--- /dev/null
+++ b/schemas/flow-version-prune.json
@@ -0,0 +1,642 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "FlowVersionPruneCommandReport",
+  "description": "C4 CLI retention policy, exact approved targets, and independent normal-delete results.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "contractVersion",
+    "mode",
+    "targetOrg",
+    "apiVersion",
+    "dryRun",
+    "confirmed",
+    "outcome",
+    "plan",
+    "deletion"
+  ],
+  "properties": {
+    "contractVersion": {
+      "const": "1"
+    },
+    "mode": {
+      "const": "RETENTION"
+    },
+    "targetOrg": {
+      "type": "string"
+    },
+    "apiVersion": {
+      "type": "string"
+    },
+    "dryRun": {
+      "type": "boolean"
+    },
+    "confirmed": {
+      "type": "boolean"
+    },
+    "outcome": {
+      "enum": ["PREVIEWED", "CANCELLED", "SUCCEEDED", "PARTIAL", "FAILED", "UNKNOWN"]
+    },
+    "plan": {
+      "$ref": "#/definitions/RetentionPlan"
+    },
+    "deletion": {
+      "anyOf": [
+        {
+          "type": "null"
+        },
+        {
+          "$ref": "#/definitions/RetentionExecution"
+        }
+      ]
+    }
+  },
+  "definitions": {
+    "Error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["code", "message"],
+      "properties": {
+        "code": {
+          "type": "string"
+        },
+        "message": {
+          "type": "string"
+        }
+      }
+    },
+    "Evidence": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "sourceId",
+        "sourceType",
+        "sourceName",
+        "targetKind",
+        "targetId",
+        "targetName",
+        "channels",
+        "interviewRoles",
+        "detailsRedacted"
+      ],
+      "properties": {
+        "sourceId": {
+          "type": "string",
+          "pattern": "^[A-Za-z0-9]{18}$"
+        },
+        "sourceType": {
+          "type": "string"
+        },
+        "sourceName": {
+          "type": ["string", "null"]
+        },
+        "targetKind": {
+          "enum": ["VERSION", "OWNED_RESOURCE"]
+        },
+        "targetId": {
+          "type": "string",
+          "pattern": "^[A-Za-z0-9]{18}$"
+        },
+        "targetName": {
+          "type": ["string", "null"]
+        },
+        "channels": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "interviewRoles": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "detailsRedacted": {
+          "type": "boolean"
+        }
+      }
+    },
+    "Assessment": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["versionId", "outcome", "reasonCode", "message", "evidence"],
+      "properties": {
+        "versionId": {
+          "type": "string",
+          "pattern": "^301[A-Za-z0-9]{15}$"
+        },
+        "outcome": {
+          "enum": ["PASS", "BLOCKED", "ERROR"]
+        },
+        "reasonCode": {
+          "type": ["string", "null"]
+        },
+        "message": {
+          "type": ["string", "null"]
+        },
+        "evidence": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Evidence"
+          }
+        },
+        "counts": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["referenceCount", "pausedInterviewCount", "failedInterviewCount"],
+          "properties": {
+            "referenceCount": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "pausedInterviewCount": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "failedInterviewCount": {
+              "type": "integer",
+              "minimum": 0
+            }
+          }
+        },
+        "versionLimit": {
+          "type": "integer",
+          "minimum": 0
+        }
+      }
+    },
+    "Result": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "definitionId",
+        "versionId",
+        "flowName",
+        "namespace",
+        "versionNumber",
+        "status",
+        "assessment",
+        "error",
+        "state",
+        "targetDeleted",
+        "source"
+      ],
+      "properties": {
+        "definitionId": {
+          "type": "string",
+          "pattern": "^300[A-Za-z0-9]{15}$"
+        },
+        "versionId": {
+          "anyOf": [
+            {
+              "type": "string",
+              "pattern": "^301[A-Za-z0-9]{15}$"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "flowName": {
+          "type": "string"
+        },
+        "namespace": {
+          "type": ["string", "null"]
+        },
+        "versionNumber": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "status": {
+          "type": ["string", "null"]
+        },
+        "assessment": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/Assessment"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "error": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/Error"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "state": {
+          "enum": ["SUCCEEDED", "BLOCKED", "FAILED", "UNKNOWN", "NOT_ATTEMPTED"]
+        },
+        "targetDeleted": {
+          "type": ["boolean", "null"]
+        },
+        "source": {
+          "enum": ["ASSESSMENT", "TOOLING", "CLIENT_POLICY", "RESOLUTION", "SAFETY"]
+        }
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "state": {
+                "const": "SUCCEEDED"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "targetDeleted": {
+                "const": true
+              },
+              "error": {
+                "type": "null"
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "state": {
+                "enum": ["UNKNOWN", "NOT_ATTEMPTED"]
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "targetDeleted": {
+                "type": "null"
+              }
+            }
+          }
+        }
+      ]
+    },
+    "Version": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "versionId",
+        "versionNumber",
+        "versionName",
+        "status",
+        "createdDate",
+        "ageDays",
+        "createdById",
+        "createdByName",
+        "lastModifiedDate",
+        "referenceCount",
+        "pausedInterviewCount",
+        "failedInterviewCount",
+        "deletable",
+        "outcome",
+        "reasonCode",
+        "message",
+        "statusChangeDate",
+        "disposition",
+        "reasons"
+      ],
+      "properties": {
+        "versionId": {
+          "type": "string",
+          "pattern": "^301[A-Za-z0-9]{15}$"
+        },
+        "versionNumber": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "versionName": {
+          "type": ["string", "null"]
+        },
+        "status": {
+          "type": ["string", "null"]
+        },
+        "createdDate": {
+          "type": ["string", "null"],
+          "format": "date-time"
+        },
+        "ageDays": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "createdById": {
+          "anyOf": [
+            {
+              "type": "string",
+              "pattern": "^005[A-Za-z0-9]{15}$"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "createdByName": {
+          "type": ["string", "null"]
+        },
+        "lastModifiedDate": {
+          "type": ["string", "null"],
+          "format": "date-time"
+        },
+        "statusChangeDate": {
+          "type": ["string", "null"],
+          "format": "date-time",
+          "description": "Stored UTC status-change timestamp; null means no stored value. Omitted by older Core builds."
+        },
+        "referenceCount": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "pausedInterviewCount": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "failedInterviewCount": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "deletable": {
+          "type": "boolean"
+        },
+        "outcome": {
+          "enum": ["PASS", "BLOCKED", "ERROR"]
+        },
+        "reasonCode": {
+          "type": ["string", "null"]
+        },
+        "message": {
+          "type": ["string", "null"]
+        },
+        "disposition": {
+          "enum": ["KEPT", "CANDIDATE", "BLOCKED", "ERROR"]
+        },
+        "reasons": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "$ref": "#/definitions/Reason"
+          }
+        }
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "outcome": {
+                "const": "PASS"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "deletable": {
+                "const": true
+              },
+              "reasonCode": {
+                "type": "null"
+              },
+              "message": {
+                "type": "null"
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "outcome": {
+                "enum": ["BLOCKED", "ERROR"]
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "deletable": {
+                "const": false
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "outcome": {
+                "enum": ["PASS", "BLOCKED"]
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "referenceCount": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "pausedInterviewCount": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "failedInterviewCount": {
+                "type": "integer",
+                "minimum": 0
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "outcome": {
+                "const": "BLOCKED"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "message": {
+                "type": "string",
+                "minLength": 1
+              }
+            }
+          }
+        }
+      ]
+    },
+    "Flow": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["definitionId", "apiName", "label", "versionCount", "limitPercent", "versions"],
+      "properties": {
+        "definitionId": {
+          "type": "string",
+          "pattern": "^300[A-Za-z0-9]{15}$"
+        },
+        "apiName": {
+          "type": "string",
+          "minLength": 1
+        },
+        "label": {
+          "type": ["string", "null"]
+        },
+        "versionCount": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "limitPercent": {
+          "type": ["integer", "null"],
+          "minimum": 0
+        },
+        "versions": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Version"
+          }
+        }
+      }
+    },
+    "Reason": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["code", "message"],
+      "properties": {
+        "code": {
+          "type": "string",
+          "minLength": 1
+        },
+        "message": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    },
+    "Policy": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["keepLatest", "olderThanDays"],
+      "properties": {
+        "keepLatest": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "olderThanDays": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 36500
+        }
+      }
+    },
+    "RetentionPlan": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["orgId", "generatedAt", "scope", "policy", "flows"],
+      "properties": {
+        "orgId": {
+          "type": "string",
+          "pattern": "^00D[A-Za-z0-9]{15}$"
+        },
+        "generatedAt": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "scope": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["all", "flowName", "namespace", "allNamespaces"],
+          "properties": {
+            "all": {
+              "type": "boolean"
+            },
+            "flowName": {
+              "type": ["string", "null"]
+            },
+            "namespace": {
+              "type": "null"
+            },
+            "allNamespaces": {
+              "type": "boolean"
+            }
+          }
+        },
+        "policy": {
+          "$ref": "#/definitions/Policy"
+        },
+        "flows": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Flow"
+          }
+        }
+      }
+    },
+    "RetentionExecution": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["outcome", "results", "warnings"],
+      "properties": {
+        "outcome": {
+          "enum": ["SUCCEEDED", "PARTIAL", "FAILED", "UNKNOWN"]
+        },
+        "results": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Result"
+          }
+        },
+        "warnings": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    }
+  },
+  "allOf": [
+    {
+      "if": {
+        "properties": {
+          "outcome": {
+            "const": "PREVIEWED"
+          }
+        }
+      },
+      "then": {
+        "properties": {
+          "dryRun": {
+            "const": true
+          },
+          "confirmed": {
+            "const": false
+          },
+          "deletion": {
+            "type": "null"
+          }
+        }
+      }
+    },
+    {
+      "if": {
+        "properties": {
+          "outcome": {
+            "const": "CANCELLED"
+          }
+        }
+      },
+      "then": {
+        "properties": {
+          "confirmed": {
+            "const": false
+          },
+          "deletion": {
+            "type": "null"
+          }
+        }
+      }
+    }
+  ]
+}
diff --git a/src/commands/flow/dependencies.ts b/src/commands/flow/dependencies.ts
new file mode 100644
index 0000000..55c0f31
--- /dev/null
+++ b/src/commands/flow/dependencies.ts
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Messages } from '@salesforce/core';
+import { Flags, SfCommand } from '@salesforce/sf-plugins-core';
+import { DependencyService, type DependencyReport } from '../../services/dependencyService.js';
+
+Messages.importMessagesDirectoryFromMetaUrl(import.meta.url);
+const messages = Messages.loadMessages('@salesforce/plugin-flow', 'flow.dependencies');
+
+export type DependencyCommandReport = DependencyReport & { targetOrg: string; apiVersion: string };
+
+const terminalText = (value: unknown): string => String(value).replace(/\p{Cc}/gu, ' ');
+
+export const formatDependencyReport = (report: DependencyCommandReport): string => {
+  const lines = [
+    '=== Flow dependencies',
+    `Target org: ${terminalText(report.targetOrg)} | API: ${report.apiVersion} | Version policy: ${
+      report.versionPolicy
+    }`,
+    `Root: ${report.root.flowName} (v${report.root.versionNumber}, ${terminalText(report.root.status)})`,
+    `Definition: ${report.root.definitionId} | Version: ${report.root.versionId}`,
+  ];
+
+  for (const direction of ['incoming', 'outgoing'] as const) {
+    const relationships = report.relationships.filter((edge) => edge.direction === direction);
+    lines.push('', direction === 'incoming' ? '=== Incoming references' : '=== Outgoing dependencies');
+    if (relationships.length === 0) lines.push('  None reported within the inspected providers and scan scope.');
+    for (const edge of relationships) {
+      const version =
+        edge.callerVersion === undefined ? '' : ` (v${edge.callerVersion}, ${terminalText(edge.callerStatus)})`;
+      lines.push(
+        `  ${terminalText(edge.callerType)}: ${terminalText(edge.callerName)}${version}`,
+        `    -> ${terminalText(edge.targetType)}: ${terminalText(edge.targetName)}`,
+        `    Evidence: ${terminalText(edge.evidence)}${
+          edge.elementName ? ` | Element: ${terminalText(edge.elementName)}` : ''
+        }`
+      );
+    }
+  }
+
+  return `\n${lines.join('\n')}\n`;
+};
+
+export default class Dependencies extends SfCommand<DependencyCommandReport> {
+  public static readonly summary = messages.getMessage('summary');
+  public static readonly description = messages.getMessage('description');
+  public static readonly examples = messages.getMessages('examples');
+
+  public static readonly flags = {
+    'target-org': Flags.requiredOrg(),
+    'api-version': Flags.orgApiVersion(),
+    'flow-name': Flags.string({ char: 'f', required: true, summary: messages.getMessage('flags.flow-name.summary') }),
+    namespace: Flags.string({ summary: messages.getMessage('flags.namespace.summary') }),
+    'scan-flow': Flags.string({ multiple: true, summary: messages.getMessage('flags.scan-flow.summary') }),
+    'version-policy': Flags.string({
+      options: ['latest', 'active'],
+      default: 'latest',
+      summary: messages.getMessage('flags.version-policy.summary'),
+    }),
+  };
+
+  public async run(): Promise<DependencyCommandReport> {
+    const { flags } = await this.parse(Dependencies);
+    const conn = flags['target-org'].getConnection(flags['api-version']);
+    const service = new DependencyService({
+      async query<T>(soql: string): Promise<{ records: T[]; totalSize: number; done: boolean }> {
+        const result = await conn.tooling.query(soql);
+        return { records: result.records as T[], totalSize: result.totalSize, done: result.done };
+      },
+    });
+    const report: DependencyCommandReport = {
+      ...(await service.analyze({
+        flowName: flags['flow-name'],
+        namespace: flags.namespace,
+        scanFlows: flags['scan-flow'],
+        versionPolicy: flags['version-policy'] as 'latest' | 'active',
+      })),
+      targetOrg: flags['target-org'].getUsername() ?? 'authenticated org',
+      apiVersion: conn.getApiVersion(),
+    };
+    if (!this.jsonEnabled()) this.log(formatDependencyReport(report));
+    return report;
+  }
+
+  protected async catch(error: Error): Promise<never> {
+    const humanOutput = !this.jsonEnabled();
+    if (humanOutput) this.logToStderr('');
+    try {
+      return await super.catch(error);
+    } finally {
+      if (humanOutput) this.logToStderr('');
+    }
+  }
+}
diff --git a/src/commands/flow/version/delete.ts b/src/commands/flow/version/delete.ts
new file mode 100644
index 0000000..b9fd688
--- /dev/null
+++ b/src/commands/flow/version/delete.ts
@@ -0,0 +1,251 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { stripVTControlCharacters } from 'node:util';
+import { Messages, SfError } from '@salesforce/core';
+import {
+  FlowVersionDeleteService,
+  ConnectToolingFlowVersionDeleteClient,
+  FlowVersionError,
+  type FlowVersionDeleteExecutionReport,
+  type FlowVersionDeletePlan,
+  type FlowVersionDeleteTarget,
+} from '@salesforce/flow-node';
+import { Flags, SfCommand } from '@salesforce/sf-plugins-core';
+import { ConfirmationPrompt } from '../../../ux/confirmation.js';
+import {
+  assertForceDeleteTerminal,
+  forceDeleteVersionNumber,
+  runForceVersionDeletion,
+  type FlowVersionForceDeleteCommandReport,
+} from '../../../services/flowVersionForceDeletion.js';
+
+Messages.importMessagesDirectoryFromMetaUrl(import.meta.url);
+const messages = Messages.loadMessages('@salesforce/plugin-flow', 'flow.version.delete');
+
+export type FlowVersionDeleteCommandReport = {
+  contractVersion: '2';
+  mode: 'NORMAL';
+  targetOrg: string;
+  apiVersion: string;
+  dryRun: boolean;
+  confirmed: boolean;
+  outcome: FlowVersionDeleteExecutionReport['outcome'] | 'PREVIEWED' | 'CANCELLED';
+  plan: FlowVersionDeletePlan;
+  deletion: FlowVersionDeleteExecutionReport | null;
+};
+
+type ArgumentFlag = { type: 'option' | 'boolean'; char?: string; aliases?: readonly string[] };
+
+const normalizeVersionDeleteArgv = (argv: string[], flags: Record<string, ArgumentFlag>): string[] => {
+  const bareOptions = new Set(['target-org', 'flow', 'versions', 'namespace', 'api-version']);
+  const longFlags = new Map<string, ArgumentFlag>();
+  const shortFlags = new Map<string, ArgumentFlag>();
+  for (const [name, flag] of Object.entries(flags)) {
+    longFlags.set(name, flag);
+    for (const alias of flag.aliases ?? []) longFlags.set(alias, flag);
+    if (flag.char) shortFlags.set(flag.char, flag);
+  }
+  const normalized: string[] = [];
+  for (let index = 0; index < argv.length; index++) {
+    const token = argv[index];
+    if (token === '--') {
+      normalized.push(...argv.slice(index));
+      break;
+    }
+    let consumesValue = false;
+    if (bareOptions.has(token)) {
+      normalized.push(`--${token}`);
+      consumesValue = true;
+    } else {
+      normalized.push(token);
+      if (token.startsWith('--')) {
+        consumesValue = !token.includes('=') && longFlags.get(token.slice(2))?.type === 'option';
+      } else if (token.startsWith('-')) {
+        const characters = token.slice(1);
+        for (let position = 0; position < characters.length; position++) {
+          const flag = shortFlags.get(characters[position]);
+          if (!flag) break;
+          if (flag.type === 'option') {
+            consumesValue = position === characters.length - 1;
+            break;
+          }
+        }
+      }
+    }
+    if (consumesValue && index + 1 < argv.length) normalized.push(argv[++index]);
+  }
+  return normalized;
+};
+
+const terminalText = (value: unknown): string =>
+  stripVTControlCharacters(String(value)).replace(/[\p{Cc}\p{Cf}]/gu, ' ');
+
+const sdkError = (error: unknown): never => {
+  if (error instanceof FlowVersionError) throw new SfError(error.message, error.code);
+  throw error;
+};
+
+const assessmentDetails = (target: FlowVersionDeleteTarget): string[] => {
+  const lines: string[] = [];
+  if (target.error) {
+    lines.push(`    ${terminalText(target.error.code)}: ${terminalText(target.error.message)}`);
+  } else if (target.assessment && target.assessment.outcome !== 'PASS') {
+    lines.push(`    ${terminalText(target.assessment.message ?? target.assessment.reasonCode ?? 'Assessment error')}`);
+  }
+  for (const evidence of target.assessment?.evidence ?? []) {
+    const name = evidence.detailsRedacted ? 'Details unavailable' : evidence.sourceName ?? evidence.sourceId;
+    lines.push(`    Reference: ${terminalText(evidence.sourceType)} | ${terminalText(name)}`);
+  }
+  return lines;
+};
+
+export const formatVersionDeleteReport = (report: FlowVersionDeleteCommandReport): string => {
+  const lines = [
+    '=== Flow version deletion',
+    `Target org: ${terminalText(report.targetOrg)} | API: ${terminalText(report.apiVersion)} | Mode: NORMAL`,
+    `Flow: ${report.plan.namespace ? `${terminalText(report.plan.namespace)}__` : ''}${terminalText(
+      report.plan.flowName
+    )}`,
+    `Definition: ${terminalText(report.plan.definitionId)}`,
+    '',
+    report.deletion ? '=== Results' : '=== Selected versions',
+  ];
+  if (report.deletion) {
+    for (const result of report.deletion.results) {
+      lines.push(`  v${result.versionNumber} | ${terminalText(result.versionId ?? 'Not resolved')} | ${result.state}`);
+      if (result.source === 'CLIENT_POLICY')
+        lines.push('    Source: Client version-preservation safeguard (product policy pending)');
+      lines.push(...assessmentDetails(result));
+    }
+  } else {
+    for (const version of report.plan.versions) {
+      const assessment = version.assessment?.outcome ?? (version.error ? 'RESOLUTION FAILED' : 'Not assessed');
+      lines.push(
+        `  v${version.versionNumber} | ${terminalText(version.versionId ?? 'Not resolved')} | ${terminalText(
+          version.status ?? 'Status unavailable'
+        )} | ${assessment}`
+      );
+      lines.push(...assessmentDetails(version));
+    }
+  }
+  lines.push('', `Outcome: ${report.outcome}`);
+  for (const warning of report.deletion?.warnings ?? report.plan.warnings) {
+    lines.push(`Warning: ${terminalText(warning)}`);
+  }
+  if (report.dryRun) lines.push(messages.getMessage('dryRunNotice'));
+  return `\n${lines.join('\n')}\n`;
+};
+
+export default class FlowVersionDelete extends SfCommand<
+  FlowVersionDeleteCommandReport | FlowVersionForceDeleteCommandReport
+> {
+  public static readonly summary = messages.getMessage('summary');
+  public static readonly description = messages.getMessage('description');
+  public static readonly examples = messages.getMessages('examples');
+  public static readonly strict = false;
+
+  public static readonly flags = {
+    'target-org': Flags.requiredOrg(),
+    'api-version': Flags.orgApiVersion(),
+    flow: Flags.string({ char: 'f', required: true, summary: messages.getMessage('flags.flow.summary') }),
+    versions: Flags.string({ required: true, summary: messages.getMessage('flags.versions.summary') }),
+    namespace: Flags.string({ summary: messages.getMessage('flags.namespace.summary') }),
+    'dry-run': Flags.boolean({ default: false, summary: messages.getMessage('flags.dry-run.summary') }),
+    yes: Flags.boolean({ char: 'y', default: false, summary: messages.getMessage('flags.yes.summary') }),
+    force: Flags.boolean({ default: false, summary: messages.getMessage('flags.force.summary') }),
+  };
+
+  public async run(): Promise<FlowVersionDeleteCommandReport | FlowVersionForceDeleteCommandReport> {
+    const { flags } = await this.parse(
+      {
+        flags: FlowVersionDelete.flags,
+        baseFlags: FlowVersionDelete.baseFlags,
+        enableJsonFlag: FlowVersionDelete.enableJsonFlag,
+        strict: true,
+      },
+      normalizeVersionDeleteArgv(this.argv, {
+        ...FlowVersionDelete.baseFlags,
+        ...FlowVersionDelete.flags,
+        json: { type: 'boolean' },
+      })
+    );
+    if (flags.force) {
+      const versionNumber = forceDeleteVersionNumber(flags.versions);
+      const json = this.jsonEnabled();
+      assertForceDeleteTerminal(json, flags['dry-run']);
+      const org = flags['target-org'];
+      return runForceVersionDeletion({
+        connection: org.getConnection(flags['api-version']),
+        targetOrg: org.getUsername() ?? 'authenticated org',
+        flowName: flags.flow,
+        versionNumber,
+        namespace: flags.namespace,
+        dryRun: flags['dry-run'],
+        yes: flags.yes,
+        json,
+        display: (message: string): void => (json ? this.logToStderr(message) : this.log(message)),
+      });
+    }
+    if (!flags['dry-run'] && !flags.yes && (this.jsonEnabled() || !process.stdin.isTTY)) {
+      throw new SfError(messages.getMessage('confirmationRequired'), 'ConfirmationRequired');
+    }
+    const org = flags['target-org'];
+    const connection = org.getConnection(flags['api-version']);
+    const service = new FlowVersionDeleteService(new ConnectToolingFlowVersionDeleteClient(connection));
+    const plan = await service
+      .plan({ flowName: flags.flow, versions: flags.versions, namespace: flags.namespace })
+      .catch(sdkError);
+    const report: FlowVersionDeleteCommandReport = {
+      contractVersion: '2',
+      mode: 'NORMAL',
+      targetOrg: org.getUsername() ?? 'authenticated org',
+      apiVersion: connection.getApiVersion(),
+      dryRun: flags['dry-run'],
+      confirmed: false,
+      outcome: 'PREVIEWED',
+      plan,
+      deletion: null,
+    };
+    if (report.dryRun) {
+      if (!this.jsonEnabled()) this.log(formatVersionDeleteReport(report));
+      return report;
+    }
+    if (!flags.yes) {
+      this.log(formatVersionDeleteReport(report));
+      const confirmed = await new ConfirmationPrompt().confirm({
+        message: messages.getMessage('confirmDelete', [plan.versions.length, report.targetOrg]),
+        ms: 60_000,
+        defaultAnswer: false,
+      });
+      if (!confirmed) {
+        report.outcome = 'CANCELLED';
+        this.log(messages.getMessage('cancelled'));
+        return report;
+      }
+    }
+    report.confirmed = true;
+    report.deletion = await service.execute(plan).catch(sdkError);
+    report.outcome = report.deletion.outcome;
+    if (report.deletion.results.some((result) => ['FAILED', 'UNKNOWN', 'NOT_ATTEMPTED'].includes(result.state))) {
+      process.exitCode = 2;
+    } else if (report.deletion.results.some((result) => result.state === 'BLOCKED')) {
+      process.exitCode = 1;
+    }
+    if (!this.jsonEnabled()) this.log(formatVersionDeleteReport(report));
+    return report;
+  }
+}
diff --git a/src/commands/flow/version/list.ts b/src/commands/flow/version/list.ts
new file mode 100644
index 0000000..8db71d8
--- /dev/null
+++ b/src/commands/flow/version/list.ts
@@ -0,0 +1,147 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { stripVTControlCharacters } from 'node:util';
+import { Messages, SfError } from '@salesforce/core';
+import {
+  ConnectFlowVersionListClient,
+  FlowVersionError,
+  type ConnectFlowVersionListReport,
+  type ConnectFlowVersionListVersion,
+} from '@salesforce/flow-node';
+import { Flags, SfCommand } from '@salesforce/sf-plugins-core';
+import { formatFlowVersionTable, type FlowVersionTableRow } from '../../../ux/flowVersionTable.js';
+
+Messages.importMessagesDirectoryFromMetaUrl(import.meta.url);
+const messages = Messages.loadMessages('@salesforce/plugin-flow', 'flow.version.list');
+
+export type FlowVersionListCommandReport = ConnectFlowVersionListReport & {
+  targetOrg: string;
+  apiVersion: string;
+};
+
+const terminalText = (value: unknown): string =>
+  stripVTControlCharacters(String(value)).replace(/[\p{Cc}\p{Cf}]/gu, ' ');
+
+const sdkError = (error: unknown): never => {
+  if (error instanceof FlowVersionError) throw new SfError(error.message, error.code);
+  throw error;
+};
+
+const tableRow = (row: ConnectFlowVersionListVersion): FlowVersionTableRow => ({
+  versionName: row.versionName ?? 'Name unavailable',
+  version: String(row.versionNumber),
+  status: row.status ?? 'Unavailable',
+  age: row.ageDays === null ? 'Unavailable' : `${row.ageDays}d`,
+  creator: row.createdByName ?? 'Name unavailable',
+  createdDate: row.createdDate ?? 'Unavailable',
+  lastModifiedDate: row.lastModifiedDate ?? 'Unavailable',
+  references: row.referenceCount === null ? 'Unavailable' : String(row.referenceCount),
+  paused: row.pausedInterviewCount === null ? 'Unavailable' : String(row.pausedInterviewCount),
+  failed: row.failedInterviewCount === null ? 'Unavailable' : String(row.failedInterviewCount),
+  deletable: row.outcome === 'PASS' ? 'Yes' : row.outcome === 'BLOCKED' ? 'No' : 'Error',
+  reason: row.outcome === 'PASS' ? '—' : row.message ?? row.reasonCode ?? 'Assessment failed',
+});
+
+export const formatVersionListReport = (report: FlowVersionListCommandReport, width?: number): string => {
+  const lines = [
+    '=== Flow versions',
+    `Target org: ${terminalText(report.targetOrg)} | API: ${terminalText(report.apiVersion)}`,
+    `Scope: ${terminalText(report.scope.all ? 'all Flows' : report.scope.flowName)}`,
+  ];
+  const filters = [
+    report.filters.status === null ? null : `status=${terminalText(report.filters.status)}`,
+    report.filters.olderThan === null ? null : `older-than=${terminalText(report.filters.olderThan)}`,
+    report.filters.minPercent === null ? null : `min-percent=${report.filters.minPercent}`,
+    report.filters.deletable ? 'deletable=true' : null,
+  ].filter((filter): filter is string => filter !== null);
+  if (filters.length > 0) lines.push(`Filters: ${filters.join(' | ')}`);
+  for (const flow of report.flows) {
+    const count = flow.versionCount === null ? 'count unavailable' : String(flow.versionCount);
+    const percent = flow.limitPercent === null ? 'percentage unavailable' : `${flow.limitPercent}%`;
+    lines.push(
+      '',
+      `=== ${terminalText(flow.apiName)}`,
+      `Version usage: ${count}/${report.versionLimit} (${percent}) before filtering`,
+      '',
+      formatFlowVersionTable(flow.versions.map(tableRow), width)
+    );
+  }
+  if (report.returnedVersionCount === 0) {
+    lines.push(
+      '',
+      report.listTruncated
+        ? 'No matching Flow versions were returned in the inspected scope; the server reports an incomplete list.'
+        : 'No Flow versions match the selected scope and filters.'
+    );
+  }
+  if (report.listTruncated) {
+    lines.push(
+      '',
+      'Warning: The server reports a truncated list. The displayed versions are not a complete inventory.'
+    );
+  }
+  return `\n${lines.join('\n')}\n`;
+};
+
+export default class FlowVersionList extends SfCommand<FlowVersionListCommandReport> {
+  public static readonly summary = messages.getMessage('summary');
+  public static readonly description = messages.getMessage('description');
+  public static readonly examples = messages.getMessages('examples');
+
+  public static readonly flags = {
+    'target-org': Flags.requiredOrg(),
+    'api-version': Flags.orgApiVersion(),
+    flow: Flags.string({ char: 'f', exclusive: ['all'], summary: messages.getMessage('flags.flow.summary') }),
+    all: Flags.boolean({ default: false, exclusive: ['flow'], summary: messages.getMessage('flags.all.summary') }),
+    namespace: Flags.string({ summary: messages.getMessage('flags.namespace.summary') }),
+    status: Flags.string({ summary: messages.getMessage('flags.status.summary') }),
+    'older-than': Flags.string({ summary: messages.getMessage('flags.older-than.summary') }),
+    'min-percent': Flags.integer({ summary: messages.getMessage('flags.min-percent.summary') }),
+    deletable: Flags.boolean({ default: false, summary: messages.getMessage('flags.deletable.summary') }),
+  };
+
+  public async run(): Promise<FlowVersionListCommandReport> {
+    const { flags } = await this.parse(FlowVersionList);
+    if (!flags.flow && !flags.all) throw new SfError(messages.getMessage('scopeRequired'), 'FlowVersionScopeRequired');
+    if (flags['min-percent'] !== undefined && (flags['min-percent'] < 0 || flags['min-percent'] > 100)) {
+      throw new SfError(messages.getMessage('invalidMinPercent'), 'InvalidVersionUsagePercent');
+    }
+    const org = flags['target-org'];
+    const connection = org.getConnection(flags['api-version']);
+    const inventory = await new ConnectFlowVersionListClient(connection)
+      .list({
+        ...(flags.flow === undefined ? {} : { flowName: flags.flow }),
+        all: flags.all,
+        ...(flags.namespace === undefined ? {} : { namespace: flags.namespace }),
+        ...(flags.status === undefined ? {} : { status: flags.status }),
+        ...(flags['older-than'] === undefined ? {} : { olderThan: flags['older-than'] }),
+        ...(flags['min-percent'] === undefined ? {} : { minPercent: flags['min-percent'] }),
+        deletable: flags.deletable,
+      })
+      .catch(sdkError);
+    const report: FlowVersionListCommandReport = {
+      ...inventory,
+      targetOrg: org.getUsername() ?? 'authenticated org',
+      apiVersion: connection.getApiVersion(),
+    };
+    if (!this.jsonEnabled()) this.log(formatVersionListReport(report));
+    if (report.listTruncated || report.flows.some((flow) => flow.versions.some((row) => row.outcome === 'ERROR'))) {
+      process.exitCode = 1;
+    }
+    return report;
+  }
+}
diff --git a/src/commands/flow/version/prune.ts b/src/commands/flow/version/prune.ts
new file mode 100644
index 0000000..29926a1
--- /dev/null
+++ b/src/commands/flow/version/prune.ts
@@ -0,0 +1,218 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { stripVTControlCharacters } from 'node:util';
+import { Messages, SfError } from '@salesforce/core';
+import {
+  ConnectFlowVersionListClient,
+  ConnectToolingFlowVersionDeleteClient,
+  FlowVersionError,
+  type FlowVersionDeleteResult,
+} from '@salesforce/flow-node';
+import { Flags, SfCommand } from '@salesforce/sf-plugins-core';
+import { ConfirmationPrompt } from '../../../ux/confirmation.js';
+import {
+  FlowVersionRetentionService,
+  retentionPolicy,
+  retentionInterimNotice,
+  type RetentionPlan,
+  type RetentionExecution,
+  type RetentionPolicy,
+  type RetentionVersion,
+} from '../../../services/flowVersionRetention.js';
+
+Messages.importMessagesDirectoryFromMetaUrl(import.meta.url);
+const messages = Messages.loadMessages('@salesforce/plugin-flow', 'flow.version.prune');
+
+export type FlowVersionPruneCommandReport = {
+  contractVersion: '1';
+  mode: 'RETENTION';
+  targetOrg: string;
+  apiVersion: string;
+  dryRun: boolean;
+  confirmed: boolean;
+  outcome: RetentionExecution['outcome'] | 'PREVIEWED' | 'CANCELLED';
+  plan: RetentionPlan;
+  deletion: RetentionExecution | null;
+};
+
+const text = (value: unknown): string => stripVTControlCharacters(String(value)).replace(/[\p{Cc}\p{Cf}]/gu, ' ');
+const sdkError = (error: unknown): never => {
+  if (error instanceof FlowVersionError) throw new SfError(error.message, error.code);
+  throw error;
+};
+
+const versionLines = (row: RetentionVersion): string[] => {
+  const lines = [
+    `  v${row.versionNumber} | ${text(row.status ?? 'Status unavailable')} | Age: ${
+      row.ageDays === null ? 'Unavailable' : `${row.ageDays}d`
+    } | ${row.disposition}`,
+    `    ${row.reasons.map((item) => `${text(item.code)}: ${text(item.message)}`).join(' ')}`,
+  ];
+  if (row.status === 'Obsolete')
+    lines.push(`    Status changed: ${text(row.statusChangeDate ?? 'No stored timestamp')}`);
+  if (row.outcome !== 'PASS')
+    lines.push(`    Core: ${row.outcome} | ${text(row.message ?? row.reasonCode ?? 'Assessment error')}`);
+  return lines;
+};
+const resultLines = (result: FlowVersionDeleteResult): string[] => {
+  const lines = [`  ${text(result.flowName)} v${result.versionNumber} | ${result.state}`];
+  if (result.error) lines.push(`    ${text(result.error.code)}: ${text(result.error.message)}`);
+  if (result.assessment?.outcome !== 'PASS' && result.assessment?.message)
+    lines.push(`    ${text(result.assessment.message)}`);
+  for (const evidence of result.assessment?.evidence ?? [])
+    lines.push(
+      `    Reference: ${text(evidence.sourceType)} | ${text(
+        evidence.detailsRedacted ? 'Details unavailable' : evidence.sourceName ?? evidence.sourceId
+      )}`
+    );
+  return lines;
+};
+
+const executionSummary = (
+  plan: RetentionPlan,
+  deletion: RetentionExecution
+): { outcome: RetentionExecution['outcome']; exitCode: 0 | 1 | 2 } => {
+  const error =
+    deletion.results.some((row) => ['FAILED', 'UNKNOWN', 'NOT_ATTEMPTED'].includes(row.state)) ||
+    plan.flows.some((flow) => flow.versions.some((row) => row.disposition === 'ERROR'));
+  const blocked =
+    deletion.results.some((row) => row.state === 'BLOCKED') ||
+    plan.flows.some((flow) => flow.versions.some((row) => row.disposition === 'BLOCKED'));
+  const exitCode = error ? 2 : blocked ? 1 : 0;
+  const outcome =
+    exitCode > 0 && deletion.outcome === 'SUCCEEDED'
+      ? deletion.results.some((row) => row.state === 'SUCCEEDED')
+        ? 'PARTIAL'
+        : 'FAILED'
+      : deletion.outcome;
+  return { outcome, exitCode };
+};
+
+export const formatVersionPruneReport = (report: FlowVersionPruneCommandReport): string => {
+  const lines = [
+    '=== Flow version retention cleanup',
+    `Target org: ${text(report.targetOrg)} | API: ${text(report.apiVersion)}`,
+    `Policy: keep Active, latest ${report.plan.policy.keepLatest}, and interim rollback candidates; age >= ${report.plan.policy.olderThanDays}d`,
+    `Mode: ${report.dryRun ? 'Preview' : 'Execute'}`,
+  ];
+  for (const flow of report.plan.flows) {
+    lines.push('', `=== ${text(flow.apiName)}`, `Definition: ${text(flow.definitionId)}`);
+    for (const row of flow.versions) lines.push(...versionLines(row));
+  }
+  if (report.plan.flows.length === 0) lines.push('', 'No Flow versions were returned.');
+  if (report.deletion) {
+    lines.push('', '=== Deletion results');
+    for (const result of report.deletion.results) lines.push(...resultLines(result));
+  }
+  const candidates = report.plan.flows
+    .flatMap((flow) => flow.versions)
+    .filter((row) => row.disposition === 'CANDIDATE').length;
+  lines.push('', `Cleanup candidates: ${candidates}`, `Outcome: ${report.outcome}`, retentionInterimNotice);
+  if (report.dryRun || !report.confirmed) lines.push('No deletion requests were sent.');
+  else for (const warning of report.deletion?.warnings ?? []) lines.push(`Warning: ${text(warning)}`);
+  return `\n${lines.join('\n')}\n`;
+};
+
+export default class FlowVersionPrune extends SfCommand<FlowVersionPruneCommandReport> {
+  public static readonly summary = messages.getMessage('summary');
+  public static readonly description = messages.getMessage('description');
+  public static readonly examples = messages.getMessages('examples');
+  public static readonly flags = {
+    'target-org': Flags.requiredOrg(),
+    'api-version': Flags.orgApiVersion(),
+    flow: Flags.string({ char: 'f', exclusive: ['all'], summary: messages.getMessage('flags.flow.summary') }),
+    all: Flags.boolean({ default: false, exclusive: ['flow'], summary: messages.getMessage('flags.all.summary') }),
+    'keep-latest': Flags.integer({ default: 5, summary: messages.getMessage('flags.keep-latest.summary') }),
+    'older-than': Flags.string({ default: '90d', summary: messages.getMessage('flags.older-than.summary') }),
+    'dry-run': Flags.boolean({
+      default: false,
+      exclusive: ['execute', 'yes'],
+      summary: messages.getMessage('flags.dry-run.summary'),
+    }),
+    execute: Flags.boolean({
+      default: false,
+      exclusive: ['dry-run', 'yes'],
+      summary: messages.getMessage('flags.execute.summary'),
+    }),
+    yes: Flags.boolean({
+      char: 'y',
+      default: false,
+      exclusive: ['dry-run', 'execute'],
+      summary: messages.getMessage('flags.yes.summary'),
+    }),
+  };
+
+  public async run(): Promise<FlowVersionPruneCommandReport> {
+    const { flags } = await this.parse(FlowVersionPrune);
+    if (!flags.flow && !flags.all) throw new SfError(messages.getMessage('scopeRequired'), 'FlowVersionScopeRequired');
+    const policy = ((): RetentionPolicy => {
+      try {
+        return retentionPolicy(flags['keep-latest'], flags['older-than']);
+      } catch (error) {
+        return sdkError(error);
+      }
+    })();
+    if (flags.execute && (this.jsonEnabled() || !process.stdin.isTTY))
+      throw new SfError(messages.getMessage('confirmationRequired'), 'ConfirmationRequired');
+    const org = flags['target-org'];
+    const connection = org.getConnection(flags['api-version']);
+    const service = new FlowVersionRetentionService(
+      new ConnectFlowVersionListClient(connection),
+      new ConnectToolingFlowVersionDeleteClient(connection)
+    );
+    const plan = await service
+      .plan({ ...(flags.flow ? { flowName: flags.flow } : { all: true }) }, policy)
+      .catch(sdkError);
+    const report: FlowVersionPruneCommandReport = {
+      contractVersion: '1',
+      mode: 'RETENTION',
+      targetOrg: org.getUsername() ?? 'authenticated org',
+      apiVersion: connection.getApiVersion(),
+      dryRun: !flags.execute && !flags.yes,
+      confirmed: false,
+      outcome: 'PREVIEWED',
+      plan,
+      deletion: null,
+    };
+    if (report.dryRun) {
+      if (!this.jsonEnabled()) this.log(formatVersionPruneReport(report));
+      return report;
+    }
+    const count = plan.flows.flatMap((flow) => flow.versions).filter((row) => row.disposition === 'CANDIDATE').length;
+    if (flags.execute && count > 0) {
+      this.log(formatVersionPruneReport(report));
+      const confirmed = await new ConfirmationPrompt().confirm({
+        message: messages.getMessage('confirmPrune', [count, report.targetOrg]),
+        ms: 60_000,
+        defaultAnswer: false,
+      });
+      if (!confirmed) {
+        report.outcome = 'CANCELLED';
+        this.log(messages.getMessage('cancelled'));
+        return report;
+      }
+    }
+    report.confirmed = count > 0;
+    report.deletion = await service.execute(plan).catch(sdkError);
+    report.outcome = report.deletion.outcome;
+    const summary = executionSummary(plan, report.deletion);
+    process.exitCode = summary.exitCode;
+    report.outcome = summary.outcome;
+    if (!this.jsonEnabled()) this.log(formatVersionPruneReport(report));
+    return report;
+  }
+}
diff --git a/src/services/dependencyService.ts b/src/services/dependencyService.ts
new file mode 100644
index 0000000..23fbcdb
--- /dev/null
+++ b/src/services/dependencyService.ts
@@ -0,0 +1,368 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export type ToolingQueryClient = {
+  query<T>(soql: string): Promise<{ records: T[]; totalSize?: number; done?: boolean }>;
+};
+
+export type AnalyzeOptions = {
+  flowName: string;
+  namespace?: string;
+  scanFlows?: string[];
+  versionPolicy?: 'latest' | 'active';
+};
+
+export type FlowIdentity = {
+  flowName: string;
+  namespace: string | null;
+  definitionId: string;
+  versionId: string;
+  versionNumber: number;
+  status: string;
+};
+
+export type DependencyRelationship = {
+  direction: 'incoming' | 'outgoing';
+  callerType: string;
+  callerName: string;
+  callerId?: string;
+  callerVersion?: number;
+  callerStatus?: string;
+  targetType: string;
+  targetName: string;
+  targetId?: string;
+  elementName?: string;
+  evidence: 'Flow.Metadata' | 'MetadataComponentDependency';
+};
+
+export type MetadataDependencyEdge = {
+  MetadataComponentId: string | null;
+  MetadataComponentName: string | null;
+  MetadataComponentType: string | null;
+  MetadataComponentNamespace: string | null;
+  RefMetadataComponentId: string | null;
+  RefMetadataComponentName: string | null;
+  RefMetadataComponentType: string | null;
+  RefMetadataComponentNamespace: string | null;
+};
+
+export type DependencyReport = {
+  generatedAt: string;
+  root: FlowIdentity;
+  versionPolicy: 'latest' | 'active';
+  scannedFlows: FlowIdentity[];
+  relationships: DependencyRelationship[];
+  mcd: {
+    status: 'success' | 'partial' | 'failed';
+    reportedEdges: MetadataDependencyEdge[];
+    queryCount: number;
+    limit: number;
+  };
+  warnings: string[];
+  scope: {
+    flowMetadata: 'explicit-flows-only';
+    requestedFlowNames: string[];
+    orgWideComplete: false;
+    apexSourceScanned: false;
+  };
+};
+
+type FlowDefinitionRecord = {
+  Id: string;
+  DeveloperName: string;
+  NamespacePrefix: string | null;
+  ActiveVersionId: string | null;
+  LatestVersionId: string | null;
+};
+
+type FlowVersionRecord = {
+  Id: string;
+  DefinitionId: string;
+  VersionNumber: number;
+  Status: string;
+  Metadata: unknown;
+};
+
+type ReadFlow = { identity: FlowIdentity; metadata: Record<string, unknown> };
+
+const MAX_FLOW_DEFINITIONS = 20;
+const MCD_QUERY_LIMIT = 200;
+const MCD_FIELDS: Array<keyof MetadataDependencyEdge> = [
+  'MetadataComponentId',
+  'MetadataComponentName',
+  'MetadataComponentType',
+  'MetadataComponentNamespace',
+  'RefMetadataComponentId',
+  'RefMetadataComponentName',
+  'RefMetadataComponentType',
+  'RefMetadataComponentNamespace',
+];
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+const qualifiedName = (name: string, namespace: string | null): string => (namespace ? `${namespace}__${name}` : name);
+
+const soqlLiteral = (value: string): string => `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+
+function validateName(value: string, label: string): string {
+  const trimmed = value.trim();
+  if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(trimmed)) {
+    throw new Error(`${label} must be an API name containing only letters, numbers, and underscores.`);
+  }
+  return trimmed;
+}
+
+function validateId(value: string, label: string): string {
+  if (!/^[A-Za-z0-9]{15}(?:[A-Za-z0-9]{3})?$/.test(value)) {
+    throw new Error(`${label} returned an invalid Salesforce ID.`);
+  }
+  return value;
+}
+
+function metadataObject(value: unknown, name: string): Record<string, unknown> {
+  if (isRecord(value)) return value;
+  if (typeof value === 'string') {
+    try {
+      const parsed: unknown = JSON.parse(value);
+      if (isRecord(parsed)) return parsed;
+    } catch {
+      // Treat unreadable metadata as a required-read failure, not as an empty dependency list.
+    }
+  }
+  throw new Error(`Flow ${name} returned no readable Metadata; its relationships cannot be analyzed.`);
+}
+
+function mcdName(name: string | null, namespace: string | null, id: string | null): string {
+  return name ? qualifiedName(name, namespace) : id ?? '(unknown)';
+}
+
+/** Read-only, deliberately bounded dependency discovery for an explicitly supplied set of Flows. */
+export class DependencyService {
+  public constructor(private readonly client: ToolingQueryClient) {}
+
+  private static metadataRelationships(
+    flows: ReadFlow[],
+    root: FlowIdentity,
+    warnings: string[]
+  ): DependencyRelationship[] {
+    const relationships: DependencyRelationship[] = [];
+    const rootName = qualifiedName(root.flowName, root.namespace);
+    const identities = new Map<string, FlowIdentity>();
+    for (const { identity } of flows) {
+      identities.set(identity.flowName, identity);
+      identities.set(qualifiedName(identity.flowName, identity.namespace), identity);
+    }
+    for (const { identity, metadata } of flows) {
+      const rawSubflows = metadata.subflows;
+      const subflows: unknown[] = rawSubflows == null ? [] : Array.isArray(rawSubflows) ? rawSubflows : [rawSubflows];
+      for (const subflow of subflows) {
+        if (!isRecord(subflow) || typeof subflow.flowName !== 'string' || subflow.flowName.trim().length === 0) {
+          warnings.push(
+            `Flow ${qualifiedName(identity.flowName, identity.namespace)} contains an unreadable subflow target.`
+          );
+          continue;
+        }
+        const targetName = subflow.flowName.trim();
+        const target = identities.get(targetName);
+        const base = {
+          callerType: 'Flow',
+          callerName: qualifiedName(identity.flowName, identity.namespace),
+          callerId: identity.versionId,
+          callerVersion: identity.versionNumber,
+          callerStatus: identity.status,
+          targetType: 'FlowDefinition',
+          targetName: target ? qualifiedName(target.flowName, target.namespace) : targetName,
+          ...(target ? { targetId: target.definitionId } : {}),
+          ...(typeof subflow.name === 'string' ? { elementName: subflow.name } : {}),
+          evidence: 'Flow.Metadata' as const,
+        };
+        if (identity.definitionId === root.definitionId) relationships.push({ direction: 'outgoing', ...base });
+        if (targetName === root.flowName || targetName === rootName) {
+          relationships.push({ direction: 'incoming', ...base });
+        }
+      }
+    }
+    return relationships;
+  }
+
+  public async analyze(options: AnalyzeOptions): Promise<DependencyReport> {
+    const flowName = validateName(options.flowName, 'Flow name');
+    const namespace = options.namespace?.trim() ? validateName(options.namespace, 'Namespace') : null;
+    const requestedFlowNames = [
+      ...new Set([flowName, ...(options.scanFlows ?? []).map((name) => validateName(name, 'Scan Flow name'))]),
+    ];
+    if (requestedFlowNames.length > MAX_FLOW_DEFINITIONS) {
+      throw new Error(`At most ${MAX_FLOW_DEFINITIONS} explicit Flows are supported, including the root Flow.`);
+    }
+    const versionPolicy = options.versionPolicy ?? 'latest';
+    if (versionPolicy !== 'latest' && versionPolicy !== 'active') {
+      throw new Error('Version policy must be latest or active.');
+    }
+
+    const flows: ReadFlow[] = [];
+    for (const name of requestedFlowNames) {
+      // Keep the bounded org reads sequential instead of issuing a burst of metadata requests.
+      // eslint-disable-next-line no-await-in-loop
+      flows.push(await this.readFlow(name, namespace, versionPolicy));
+    }
+    const root = flows[0].identity;
+    const warnings = [
+      'Flow.Metadata scanning is limited to the explicitly requested Flows and selected versions; incoming callers are not org-wide complete.',
+      'Subflow targets are definition/name references; this report does not establish which child version executes at runtime.',
+      'MetadataComponentDependency is supplementary evidence. An empty response does not prove that no references exist.',
+      'Dependency-API rows can be definition-level and are not guaranteed to describe only the selected Flow version.',
+      'Apex source and runtime-resolved references were not scanned; this report is not a safe-delete or deployment-completeness guarantee.',
+    ];
+    const relationships = DependencyService.metadataRelationships(flows, root, warnings);
+    const mcd = await this.readMetadataDependencies(root, relationships, warnings);
+
+    return {
+      generatedAt: new Date().toISOString(),
+      root,
+      versionPolicy,
+      scannedFlows: flows.map((flow) => flow.identity),
+      relationships: [
+        ...new Map(relationships.map((relationship) => [JSON.stringify(relationship), relationship])).values(),
+      ],
+      mcd,
+      warnings,
+      scope: {
+        flowMetadata: 'explicit-flows-only',
+        requestedFlowNames,
+        orgWideComplete: false,
+        apexSourceScanned: false,
+      },
+    };
+  }
+
+  private async readFlow(
+    flowName: string,
+    namespace: string | null,
+    versionPolicy: 'latest' | 'active'
+  ): Promise<ReadFlow> {
+    const name = qualifiedName(flowName, namespace);
+    const namespacePredicate = namespace ? soqlLiteral(namespace) : 'null';
+    const definitions = await this.client.query<FlowDefinitionRecord>(
+      'SELECT Id, DeveloperName, NamespacePrefix, ActiveVersionId, LatestVersionId FROM FlowDefinition ' +
+        `WHERE DeveloperName = ${soqlLiteral(flowName)} AND NamespacePrefix = ${namespacePredicate} LIMIT 2`
+    );
+    if (definitions.records.length === 0)
+      throw new Error(`Flow definition ${name} was not found or is not accessible.`);
+    if (definitions.records.length !== 1 || (definitions.totalSize ?? 1) > 1 || definitions.done === false) {
+      throw new Error(`Flow definition ${name} did not resolve unambiguously; no version was selected.`);
+    }
+    const definition = definitions.records[0];
+    const definitionId = validateId(definition.Id, `Flow definition ${name}`);
+    const selectedId = versionPolicy === 'active' ? definition.ActiveVersionId : definition.LatestVersionId;
+    if (!selectedId) throw new Error(`Flow ${name} has no ${versionPolicy} version; no fallback version was selected.`);
+    const versionId = validateId(selectedId, `Flow ${name} ${versionPolicy} version`);
+    const versions = await this.client.query<FlowVersionRecord>(
+      `SELECT Id, DefinitionId, VersionNumber, Status, Metadata FROM Flow WHERE Id = ${soqlLiteral(versionId)} LIMIT 1`
+    );
+    if (versions.records.length !== 1 || (versions.totalSize ?? 1) > 1 || versions.done === false) {
+      throw new Error(`The selected ${versionPolicy} version for Flow ${name} was not readable as a single record.`);
+    }
+    const version = versions.records[0];
+    if (version.Id !== versionId || version.DefinitionId !== definitionId) {
+      throw new Error(`The selected version for Flow ${name} did not match its resolved definition and version IDs.`);
+    }
+    if (!Number.isInteger(version.VersionNumber) || version.VersionNumber < 1 || typeof version.Status !== 'string') {
+      throw new Error(`The selected version for Flow ${name} returned incomplete version identity.`);
+    }
+    return {
+      identity: {
+        flowName: definition.DeveloperName,
+        namespace: definition.NamespacePrefix ?? null,
+        definitionId,
+        versionId,
+        versionNumber: version.VersionNumber,
+        status: version.Status,
+      },
+      metadata: metadataObject(version.Metadata, name),
+    };
+  }
+
+  private async readMetadataDependencies(
+    root: FlowIdentity,
+    relationships: DependencyRelationship[],
+    warnings: string[]
+  ): Promise<DependencyReport['mcd']> {
+    const edges = new Map<string, MetadataDependencyEdge>();
+    let successfulQueries = 0;
+    let incomplete = false;
+    let queryCount = 0;
+    for (const id of [root.definitionId, root.versionId]) {
+      for (const direction of ['incoming', 'outgoing'] as const) {
+        const field = direction === 'incoming' ? 'RefMetadataComponentId' : 'MetadataComponentId';
+        queryCount += 1;
+        try {
+          // Four bounded requests stay sequential to avoid unnecessary concurrent load on the org.
+          // eslint-disable-next-line no-await-in-loop
+          const result = await this.client.query<MetadataDependencyEdge>(
+            `SELECT ${MCD_FIELDS.join(', ')} FROM MetadataComponentDependency ` +
+              `WHERE ${field} = ${soqlLiteral(id)} LIMIT ${MCD_QUERY_LIMIT}`
+          );
+          successfulQueries += 1;
+          if (
+            result.records.length >= MCD_QUERY_LIMIT ||
+            (result.totalSize ?? 0) >= MCD_QUERY_LIMIT ||
+            result.done === false
+          ) {
+            incomplete = true;
+            warnings.push(
+              `MetadataComponentDependency ${direction} query for ${id} reached its bounded result limit or reported more data; results may be incomplete.`
+            );
+          }
+          for (const rawEdge of result.records) {
+            const edge = Object.fromEntries(
+              MCD_FIELDS.map((key) => [key, rawEdge[key] ?? null])
+            ) as MetadataDependencyEdge;
+            edges.set(JSON.stringify(edge), edge);
+            relationships.push({
+              direction,
+              callerType: edge.MetadataComponentType ?? '(unknown)',
+              callerName: mcdName(
+                edge.MetadataComponentName,
+                edge.MetadataComponentNamespace,
+                edge.MetadataComponentId
+              ),
+              ...(edge.MetadataComponentId ? { callerId: edge.MetadataComponentId } : {}),
+              targetType: edge.RefMetadataComponentType ?? '(unknown)',
+              targetName: mcdName(
+                edge.RefMetadataComponentName,
+                edge.RefMetadataComponentNamespace,
+                edge.RefMetadataComponentId
+              ),
+              ...(edge.RefMetadataComponentId ? { targetId: edge.RefMetadataComponentId } : {}),
+              evidence: 'MetadataComponentDependency',
+            });
+          }
+        } catch (error) {
+          incomplete = true;
+          const message = error instanceof Error ? error.message : String(error);
+          warnings.push(`MetadataComponentDependency ${direction} query for ${id} failed: ${message}`);
+        }
+      }
+    }
+    return {
+      status: successfulQueries === 0 ? 'failed' : incomplete ? 'partial' : 'success',
+      reportedEdges: [...edges.values()],
+      queryCount,
+      limit: MCD_QUERY_LIMIT,
+    };
+  }
+}
diff --git a/src/services/flowVersionForceDeletion.ts b/src/services/flowVersionForceDeletion.ts
new file mode 100644
index 0000000..ebeb288
--- /dev/null
+++ b/src/services/flowVersionForceDeletion.ts
@@ -0,0 +1,199 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { stripVTControlCharacters } from 'node:util';
+import { Messages, SfError, type Connection } from '@salesforce/core';
+import {
+  ConnectFlowVersionForceDeleteClient,
+  FlowVersionForceDeleteService,
+  FlowVersionError,
+  type FlowVersionForceDeletePlan,
+  type FlowVersionForceDeleteResult,
+} from '@salesforce/flow-node';
+import { ForceDeleteConfirmationPrompt } from '../ux/forceDeleteConfirmation.js';
+
+Messages.importMessagesDirectoryFromMetaUrl(import.meta.url);
+const messages = Messages.loadMessages('@salesforce/plugin-flow', 'flow.version.delete');
+
+export type FlowVersionForceDeleteCommandReport = {
+  contractVersion: '1';
+  mode: 'FORCE';
+  targetOrg: string;
+  apiVersion: string;
+  dryRun: boolean;
+  confirmed: boolean;
+  confirmationMethod: 'TYPED_FLOW_AND_VERSION' | null;
+  outcome: FlowVersionForceDeleteResult['state'] | 'PREVIEWED' | 'CANCELLED';
+  plan: FlowVersionForceDeletePlan;
+  deletion: FlowVersionForceDeleteResult | null;
+};
+
+export type ForceDeleteCommandInput = {
+  connection: Connection;
+  targetOrg: string;
+  flowName: string;
+  versionNumber: number;
+  namespace?: string;
+  dryRun: boolean;
+  yes: boolean;
+  json: boolean;
+  display: (message: string) => void;
+};
+
+const terminalText = (value: unknown): string =>
+  stripVTControlCharacters(String(value)).replace(/[\p{Cc}\p{Cf}]/gu, ' ');
+const count = (value: number | null): string => (value === null ? 'Unavailable' : String(value));
+
+export const forceDeleteVersionNumber = (value: string): number => {
+  const number = /^[1-9]\d*$/.test(value) ? Number(value) : Number.NaN;
+  if (!Number.isSafeInteger(number)) throw new SfError(messages.getMessage('forceSingleVersion'), 'ForceSingleVersion');
+  return number;
+};
+
+export const assertForceDeleteTerminal = (json: boolean, dryRun: boolean): void => {
+  if (!process.stdin.isTTY || !process.stdout.isTTY || (json && !dryRun && !process.stderr.isTTY)) {
+    throw new SfError(messages.getMessage('forceInteractiveRequired'), 'ForceInteractiveRequired');
+  }
+};
+
+export const formatVersionForceDeleteReport = (report: FlowVersionForceDeleteCommandReport): string => {
+  const { plan } = report;
+  const { impact } = plan;
+  const flowName = impact.flowApiName ?? (plan.namespace ? `${plan.namespace}__${plan.flowName}` : plan.flowName);
+  const lines = [
+    '=== Flow version force deletion',
+    `Target org: ${terminalText(report.targetOrg)} | API: ${terminalText(report.apiVersion)} | Mode: FORCE`,
+    `Flow: ${terminalText(flowName)} | Version: ${plan.versionNumber}`,
+    `Definition: ${terminalText(plan.definitionId)} | Version ID: ${terminalText(plan.versionId)}`,
+    '',
+    '=== Impact preview',
+    `Paused interviews: ${count(impact.pausedInterviewCount)}`,
+    `Failed interviews: ${count(impact.failedInterviewCount)}`,
+    `Other saved interviews: ${count(impact.otherInterviewCount)}`,
+    `Distinct users: ${count(impact.distinctUserCount)}`,
+    `Oldest interview age: ${
+      impact.oldestInterviewAgeDays === null ? 'Unavailable' : `${impact.oldestInterviewAgeDays}d`
+    }`,
+    `Orchestrations in progress: ${count(impact.orchestrationInProgressCount)}`,
+    `Referencing Flow versions: ${count(impact.referencingVersionCount)}`,
+    `Scheduled resumes within 7 days: ${
+      impact.scheduledResumeWithin7Days === null
+        ? 'Unavailable (not stored on the interview)'
+        : count(impact.scheduledResumeWithin7Days)
+    }`,
+    `Work items: ${
+      impact.workItemCount === null ? 'Unavailable (not keyed by Flow version)' : count(impact.workItemCount)
+    }`,
+  ];
+  lines.push(
+    '',
+    `Backend eligibility: ${
+      impact.eligible ? 'ELIGIBLE' : `BLOCKED | ${terminalText(impact.reasonCode ?? 'Unavailable')}`
+    }`
+  );
+  if (plan.clientPolicyError)
+    lines.push(
+      '',
+      `Client policy: ${terminalText(plan.clientPolicyError.code)} | ${terminalText(plan.clientPolicyError.message)}`
+    );
+  lines.push('', messages.getMessage('forceIrreversible'));
+  if (report.deletion) {
+    lines.push('', '=== Result', `Outcome: ${report.outcome}`);
+    if (report.deletion.abandonedInterviewCount !== null)
+      lines.push(`Abandoned interviews: ${report.deletion.abandonedInterviewCount}`);
+    if (report.deletion.error)
+      lines.push(`${terminalText(report.deletion.error.code)}: ${terminalText(report.deletion.error.message)}`);
+    if (report.deletion.state === 'UNKNOWN') lines.push(messages.getMessage('forceUnknown'));
+  } else {
+    lines.push('', `Outcome: ${report.outcome}`, messages.getMessage('forceNoMutation'));
+  }
+  return `\n${lines.join('\n')}\n`;
+};
+
+const sdkError = (error: unknown): never => {
+  if (error instanceof FlowVersionError) throw new SfError(error.message, error.code);
+  throw error;
+};
+
+const confirmationWindow = (expiresAt: string | null): number => {
+  const remaining = expiresAt === null ? Number.NaN : Date.parse(expiresAt) - Date.now();
+  if (!Number.isFinite(remaining) || remaining < 60_000)
+    throw new SfError(messages.getMessage('forcePreviewExpiring'), 'ForcePreviewExpiring');
+  return Math.min(120_000, Math.floor(remaining));
+};
+
+export const runForceVersionDeletion = async (
+  input: ForceDeleteCommandInput
+): Promise<FlowVersionForceDeleteCommandReport> => {
+  const service = new FlowVersionForceDeleteService(new ConnectFlowVersionForceDeleteClient(input.connection));
+  const plan = await service
+    .preview({ flowName: input.flowName, versionNumber: input.versionNumber, namespace: input.namespace })
+    .catch(sdkError);
+  const report: FlowVersionForceDeleteCommandReport = {
+    contractVersion: '1',
+    mode: 'FORCE',
+    targetOrg: input.targetOrg,
+    apiVersion: input.connection.getApiVersion(),
+    dryRun: input.dryRun,
+    confirmed: false,
+    confirmationMethod: null,
+    outcome: 'PREVIEWED',
+    plan,
+    deletion: null,
+  };
+  try {
+    if (input.dryRun) {
+      if (!input.json) input.display(formatVersionForceDeleteReport(report));
+      return report;
+    }
+    if (!plan.impact.eligible || plan.clientPolicyError) {
+      report.outcome = 'BLOCKED';
+      process.exitCode = 1;
+      if (!input.json) input.display(formatVersionForceDeleteReport(report));
+      return report;
+    }
+    assertForceDeleteTerminal(input.json, input.dryRun);
+    input.display(formatVersionForceDeleteReport(report));
+    if (input.yes) input.display(messages.getMessage('forceYesIgnored'));
+    const flowApiName = plan.impact.flowApiName;
+    if (!flowApiName || plan.impact.versionNumber !== plan.versionNumber)
+      throw new SfError(messages.getMessage('forceInvalidPreview'), 'InvalidForceDeletePreview');
+    const confirmed = await new ForceDeleteConfirmationPrompt().confirm({
+      flowApiName,
+      versionNumber: plan.versionNumber,
+      flowNameMessage: messages.getMessage('forceConfirmFlow', [flowApiName]),
+      versionMessage: messages.getMessage('forceConfirmVersion', [plan.versionNumber]),
+      ms: confirmationWindow(plan.expiresAt),
+      output: input.json ? process.stderr : process.stdout,
+    });
+    if (!confirmed) {
+      report.outcome = 'CANCELLED';
+      input.display(messages.getMessage('forceCancelled'));
+      return report;
+    }
+    assertForceDeleteTerminal(input.json, input.dryRun);
+    report.confirmed = true;
+    report.confirmationMethod = 'TYPED_FLOW_AND_VERSION';
+    report.deletion = await service.execute(plan).catch(sdkError);
+    report.outcome = report.deletion.state;
+    if (report.outcome === 'BLOCKED') process.exitCode = 1;
+    else if (report.outcome !== 'SUCCEEDED') process.exitCode = 2;
+    if (!input.json) input.display(formatVersionForceDeleteReport(report));
+    return report;
+  } finally {
+    service.cancel(plan);
+  }
+};
diff --git a/src/services/flowVersionRetention.ts b/src/services/flowVersionRetention.ts
new file mode 100644
index 0000000..a2c5419
--- /dev/null
+++ b/src/services/flowVersionRetention.ts
@@ -0,0 +1,420 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  FlowVersionDeleteService,
+  FlowVersionError,
+  type ConnectFlowVersionListReport,
+  type ConnectFlowVersionListFlow,
+  type ConnectFlowVersionListVersion,
+  type FlowVersionDeleteClient,
+  type FlowVersionDeleteResult,
+  type FlowVersionInventory,
+} from '@salesforce/flow-node';
+
+export type RetentionPolicy = { keepLatest: number; olderThanDays: number };
+export type RetentionReason = { code: string; message: string };
+export type RetentionVersion = ConnectFlowVersionListVersion & {
+  disposition: 'KEPT' | 'CANDIDATE' | 'BLOCKED' | 'ERROR';
+  reasons: RetentionReason[];
+};
+export type RetentionFlow = Omit<ConnectFlowVersionListFlow, 'versions'> & { versions: RetentionVersion[] };
+export type RetentionPlan = {
+  orgId: string;
+  generatedAt: string;
+  scope: ConnectFlowVersionListReport['scope'];
+  policy: RetentionPolicy;
+  flows: RetentionFlow[];
+};
+export type RetentionExecution = {
+  outcome: 'SUCCEEDED' | 'PARTIAL' | 'FAILED' | 'UNKNOWN';
+  results: FlowVersionDeleteResult[];
+  warnings: string[];
+};
+export type RetentionScope = { flowName?: string; all?: boolean };
+export type RetentionListClient = { list(input: RetentionScope): Promise<ConnectFlowVersionListReport> };
+
+const interimNotice =
+  'Rollback protection uses the newest Obsolete statusChangeDate. Packaging can update this timestamp; the product rule remains interim.';
+const statuses = new Set(['Active', 'Draft', 'Obsolete', 'InvalidDraft', 'UnderReview']);
+const reason = (code: string, message: string): RetentionReason => ({ code, message });
+
+const rollbackReason = (datedCount: number, rollbackCount: number): RetentionReason => {
+  if (datedCount === 0)
+    return reason(
+      'ROLLBACK_TIME_UNAVAILABLE',
+      'Keep all Obsolete versions because no stored status-change timestamp identifies a rollback candidate.'
+    );
+  if (rollbackCount > 1)
+    return reason('ROLLBACK_TIME_TIE', 'Keep every Obsolete version tied for the newest statusChangeDate.');
+  return reason(
+    'PREVIOUSLY_ACTIVE',
+    'Keep the Obsolete version with the newest statusChangeDate (interim rollback rule).'
+  );
+};
+const stopsExecution = (row: FlowVersionDeleteResult): boolean =>
+  row.state === 'UNKNOWN' ||
+  row.state === 'NOT_ATTEMPTED' ||
+  row.error?.code === 'ORG_MISMATCH' ||
+  row.error?.code === 'ORG_CONTEXT_UNAVAILABLE';
+
+const executionOutcome = (results: FlowVersionDeleteResult[]): RetentionExecution['outcome'] => {
+  if (results.some((row) => row.state === 'UNKNOWN')) return 'UNKNOWN';
+  const succeeded = results.filter((row) => row.state === 'SUCCEEDED').length;
+  if (succeeded === results.length) return 'SUCCEEDED';
+  return succeeded > 0 ? 'PARTIAL' : 'FAILED';
+};
+
+export const retentionPolicy = (keepLatest: number, olderThan: string): RetentionPolicy => {
+  if (!Number.isSafeInteger(keepLatest) || keepLatest < 1) {
+    throw new FlowVersionError('INVALID_RETENTION_POLICY', '--keep-latest must be an integer of at least 1.');
+  }
+  const match = /^(0|[1-9]\d*)d$/.exec(olderThan);
+  const olderThanDays = match ? Number(match[1]) : Number.NaN;
+  if (!Number.isSafeInteger(olderThanDays) || olderThanDays > 36_500) {
+    throw new FlowVersionError('INVALID_RETENTION_POLICY', '--older-than must be 0d to 36500d.');
+  }
+  return { keepLatest, olderThanDays };
+};
+
+/** Retention is CLI product policy; the C1 service alone supplies eligibility and source metadata. */
+export const classifyRetentionFlow = (flow: ConnectFlowVersionListFlow, policy: RetentionPolicy): RetentionFlow => {
+  for (const version of flow.versions) {
+    if (!Object.hasOwn(version, 'statusChangeDate')) {
+      throw new FlowVersionError(
+        'RETENTION_METADATA_UNAVAILABLE',
+        'C4 requires statusChangeDate from the Core list API. Rebuild and restart the updated backend, then preview again.'
+      );
+    }
+  }
+  const latest = new Set(
+    [...flow.versions]
+      .sort((left, right) => right.versionNumber - left.versionNumber)
+      .slice(0, policy.keepLatest)
+      .map((row) => row.versionId)
+  );
+  const obsolete = flow.versions.filter((row) => row.status === 'Obsolete');
+  const dated = obsolete.filter((row) => row.statusChangeDate !== null);
+  const newest = dated.reduce((value, row) => Math.max(value, Date.parse(row.statusChangeDate!)), -Infinity);
+  const rollback = new Set(
+    obsolete
+      .filter((row) =>
+        dated.length ? row.statusChangeDate !== null && Date.parse(row.statusChangeDate!) === newest : true
+      )
+      .map((row) => row.versionId)
+  );
+  const unknownStatus = flow.versions.some((row) => row.status === null || !statuses.has(row.status));
+  return {
+    ...flow,
+    versions: flow.versions.map((row): RetentionVersion => {
+      const reasons: RetentionReason[] = [];
+      if (row.status === 'Active') reasons.push(reason('ACTIVE_VERSION', 'Keep the Active version.'));
+      if (latest.has(row.versionId)) reasons.push(reason('LATEST_N', `Keep the latest ${policy.keepLatest} versions.`));
+      if (rollback.has(row.versionId)) reasons.push(rollbackReason(dated.length, rollback.size));
+      if (unknownStatus) {
+        reasons.push(
+          reason(
+            'RETENTION_STATUS_UNAVAILABLE',
+            'A version has no recognized status; the protected set cannot be established for this Flow.'
+          )
+        );
+        return { ...row, disposition: 'ERROR', reasons };
+      }
+      if (reasons.length > 0) return { ...row, disposition: 'KEPT', reasons };
+      if (row.ageDays === null)
+        return {
+          ...row,
+          disposition: 'ERROR',
+          reasons: [
+            reason('RETENTION_AGE_UNAVAILABLE', 'The backend did not supply the age required by the retention rule.'),
+          ],
+        };
+      if (row.ageDays < policy.olderThanDays)
+        return {
+          ...row,
+          disposition: 'KEPT',
+          reasons: [reason('AGE_THRESHOLD', `Keep versions younger than ${policy.olderThanDays} days.`)],
+        };
+      if (row.outcome === 'ERROR') {
+        return {
+          ...row,
+          disposition: 'ERROR',
+          reasons: [
+            reason(
+              row.reasonCode ?? 'ASSESSMENT_ERROR',
+              row.message ?? row.reasonCode ?? 'The backend could not assess this version.'
+            ),
+          ],
+        };
+      }
+      if (row.outcome === 'BLOCKED' || !row.deletable) {
+        return {
+          ...row,
+          disposition: 'BLOCKED',
+          reasons: [
+            reason(
+              row.reasonCode ?? 'BACKEND_BLOCKED',
+              row.message ?? row.reasonCode ?? 'The backend reports a deletion blocker.'
+            ),
+          ],
+        };
+      }
+      return {
+        ...row,
+        disposition: 'CANDIDATE',
+        reasons: [
+          reason(
+            'RETENTION_CANDIDATE',
+            'Inactive, outside the protected versions, old enough, and marked deletable by Core.'
+          ),
+        ],
+      };
+    }),
+  };
+};
+
+/** Exact prepared targets are bound to this service and org and cannot be replayed or expanded. */
+export class FlowVersionRetentionService {
+  private readonly plans = new WeakMap<
+    RetentionPlan,
+    { snapshot: RetentionPlan; serialized: string; started: boolean }
+  >();
+
+  public constructor(
+    private readonly listClient: RetentionListClient,
+    private readonly deleteClient: FlowVersionDeleteClient
+  ) {}
+
+  private static localResult(
+    flow: RetentionFlow,
+    row: RetentionVersion,
+    state: 'FAILED' | 'NOT_ATTEMPTED' | 'UNKNOWN',
+    code: string,
+    message: string
+  ): FlowVersionDeleteResult {
+    return {
+      definitionId: flow.definitionId,
+      versionId: row.versionId,
+      flowName: flow.apiName,
+      namespace: null,
+      versionNumber: row.versionNumber,
+      status: row.status,
+      assessment: null,
+      error: { code, message },
+      state,
+      targetDeleted: state === 'FAILED' ? false : null,
+      source: 'CLIENT_POLICY',
+    };
+  }
+
+  public async plan(scope: RetentionScope, policy: RetentionPolicy): Promise<RetentionPlan> {
+    const selectedPolicy = retentionPolicy(policy.keepLatest, `${policy.olderThanDays}d`);
+    const catalog = await this.catalog(scope);
+    const plan: RetentionPlan = {
+      orgId: catalog.orgId,
+      generatedAt: catalog.generatedAt,
+      scope: catalog.scope,
+      policy: selectedPolicy,
+      flows: catalog.flows.map((flow) => classifyRetentionFlow(flow, selectedPolicy)),
+    };
+    this.plans.set(plan, { snapshot: structuredClone(plan), serialized: JSON.stringify(plan), started: false });
+    return plan;
+  }
+
+  public async execute(input: RetentionPlan): Promise<RetentionExecution> {
+    const prepared = this.plans.get(input);
+    if (!prepared) {
+      throw new FlowVersionError('INVALID_RETENTION_PLAN', 'Prepare and confirm an unchanged plan with this service.');
+    }
+    if (prepared.serialized !== JSON.stringify(input)) {
+      throw new FlowVersionError('INVALID_RETENTION_PLAN', 'Prepare and confirm an unchanged plan with this service.');
+    }
+    if (prepared.started)
+      throw new FlowVersionError('RETENTION_PLAN_ALREADY_EXECUTED', 'Prepare and confirm a new retention preview.');
+    this.assertOrg(prepared.snapshot.orgId);
+    prepared.started = true;
+    const plan = structuredClone(prepared.snapshot);
+    const results: FlowVersionDeleteResult[] = [];
+    const warnings = new Set([
+      interimNotice,
+      'Client retention checks are observations, not an atomic reservation against concurrent changes.',
+    ]);
+    let stopped = false;
+    for (const flow of plan.flows) {
+      const candidates = flow.versions
+        .filter((row) => row.disposition === 'CANDIDATE')
+        .sort((left, right) => left.versionNumber - right.versionNumber);
+      // Prepare independently so a missing/replaced target never rejects its eligible siblings.
+      for (let start = 0; start < candidates.length; start++) {
+        const chunk = candidates.slice(start, start + 1);
+        if (stopped) {
+          for (const row of chunk)
+            results.push(
+              FlowVersionRetentionService.localResult(
+                flow,
+                row,
+                'NOT_ATTEMPTED',
+                'EXECUTION_STOPPED',
+                'No deletion was sent because a preceding result requires reconciliation.'
+              )
+            );
+          continue;
+        }
+        // C1 provides the fully qualified API name and exact definition ID. Do not guess namespace boundaries.
+        const service = new FlowVersionDeleteService({
+          getOrgId: (): ReturnType<FlowVersionDeleteClient['getOrgId']> => this.deleteClient.getOrgId(),
+          inventory: async (): Promise<FlowVersionInventory> => {
+            const current = await this.catalog({ flowName: flow.apiName }, plan.orgId);
+            const exact = current.flows.find(
+              (item) => item.definitionId === flow.definitionId && item.apiName === flow.apiName
+            );
+            if (!exact)
+              throw new FlowVersionError('TARGET_CHANGED', 'The exact approved Flow definition is no longer present.');
+            return {
+              definitionId: exact.definitionId,
+              flowName: flow.apiName,
+              namespace: null,
+              versions: exact.versions.map((row) => {
+                if (row.status === null || !statuses.has(row.status))
+                  throw new FlowVersionError('RETENTION_STATUS_UNAVAILABLE', 'Current version status is unavailable.');
+                return {
+                  definitionId: exact.definitionId,
+                  versionId: row.versionId,
+                  flowName: flow.apiName,
+                  namespace: null,
+                  versionNumber: row.versionNumber,
+                  status: row.status,
+                };
+              }),
+            };
+          },
+          assessVersions: (targets): ReturnType<FlowVersionDeleteClient['assessVersions']> =>
+            this.deleteClient.assessVersions(targets),
+          deleteVersion: (versionId): ReturnType<FlowVersionDeleteClient['deleteVersion']> =>
+            this.deleteClient.deleteVersion(versionId),
+        });
+        let executionStarted = false;
+        try {
+          // eslint-disable-next-line no-await-in-loop -- Independent mutations must remain strictly ordered.
+          const deletionPlan = await service.plan({
+            flowName: flow.apiName,
+            versions: chunk.map((row) => row.versionNumber).join(','),
+          });
+          if (
+            deletionPlan.definitionId !== flow.definitionId ||
+            deletionPlan.versions.some((target, index) => target.versionId !== chunk[index]?.versionId)
+          ) {
+            throw new FlowVersionError(
+              'TARGET_CHANGED',
+              'The exact approved versions changed. No replacements were selected.'
+            );
+          }
+          executionStarted = true;
+          // eslint-disable-next-line no-await-in-loop -- An uncertain result must stop every later mutation.
+          const execution = await service.execute(deletionPlan, {
+            beforeDelete: async (target) => {
+              if (target.versionId !== chunk[0]?.versionId || target.definitionId !== flow.definitionId)
+                return {
+                  allowed: false,
+                  code: 'TARGET_CHANGED',
+                  message: 'The target differs from the exact approved version.',
+                };
+              const current = await this.catalog({ flowName: flow.apiName }, plan.orgId);
+              const exact = current.flows.find(
+                (item) => item.definitionId === flow.definitionId && item.apiName === flow.apiName
+              );
+              if (!exact)
+                return {
+                  allowed: false,
+                  code: 'TARGET_CHANGED',
+                  message: 'The approved definition is no longer present.',
+                };
+              const fresh = classifyRetentionFlow(exact, plan.policy).versions.find(
+                (row) => row.versionId === target.versionId && row.versionNumber === target.versionNumber
+              );
+              if (!fresh)
+                return {
+                  allowed: false,
+                  code: 'TARGET_CHANGED',
+                  message: 'The exact approved version is no longer present.',
+                };
+              if (fresh.disposition === 'ERROR')
+                throw new FlowVersionError(
+                  'RETENTION_RECHECK_ERROR',
+                  fresh.reasons.map((item) => item.message).join(' ')
+                );
+              if (fresh.disposition !== 'CANDIDATE')
+                return {
+                  allowed: false,
+                  code: 'RETENTION_RECHECK_BLOCKED',
+                  message: fresh.reasons.map((item) => item.message).join(' '),
+                };
+              return { allowed: true };
+            },
+          });
+          results.push(...execution.results);
+          for (const warning of execution.warnings) warnings.add(warning);
+          stopped = execution.results.some(stopsExecution);
+        } catch (error) {
+          const detail =
+            error instanceof FlowVersionError
+              ? { code: error.code, message: error.message }
+              : {
+                  code: 'RETENTION_REVALIDATION_FAILED',
+                  message:
+                    'The approved retention selection could not be revalidated. No deletion was sent for this group.',
+                };
+          for (const row of chunk)
+            results.push(
+              FlowVersionRetentionService.localResult(
+                flow,
+                row,
+                executionStarted ? 'UNKNOWN' : 'FAILED',
+                detail.code,
+                executionStarted
+                  ? 'Execution did not return a complete report. Reconcile the selected version IDs before trying again.'
+                  : detail.message
+              )
+            );
+          stopped = executionStarted || detail.code === 'ORG_MISMATCH' || detail.code === 'ORG_CONTEXT_UNAVAILABLE';
+        }
+      }
+    }
+    return { outcome: executionOutcome(results), results, warnings: [...warnings] };
+  }
+
+  private async catalog(scope: RetentionScope, expectedOrg?: string): Promise<ConnectFlowVersionListReport> {
+    const orgId = expectedOrg ?? this.deleteClient.getOrgId();
+    this.assertOrg(orgId);
+    const report = await this.listClient.list(scope);
+    this.assertOrg(orgId);
+    if (report.orgId !== orgId)
+      throw new FlowVersionError('ORG_MISMATCH', 'The list response belongs to a different org.');
+    if (!report.catalogComplete)
+      throw new FlowVersionError(
+        'RETENTION_CATALOG_INCOMPLETE',
+        'Cleanup requires the complete unfiltered C1 catalog. No deletion was sent.'
+      );
+    return report;
+  }
+
+  private assertOrg(expected: string): void {
+    if (this.deleteClient.getOrgId() !== expected)
+      throw new FlowVersionError('ORG_MISMATCH', 'The authenticated org changed. No further deletion was sent.');
+  }
+}
+
+export const retentionInterimNotice = interimNotice;
diff --git a/src/ux/confirmation.ts b/src/ux/confirmation.ts
new file mode 100644
index 0000000..dccfa39
--- /dev/null
+++ b/src/ux/confirmation.ts
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import inquirerConfirm from '@inquirer/confirm';
+
+export type ConfirmationOptions = {
+  message: string;
+  ms?: number;
+  defaultAnswer?: boolean;
+};
+
+export class ConfirmationPrompt {
+  public constructor(private readonly prompt: typeof inquirerConfirm = inquirerConfirm) {}
+
+  public async confirm({ message, ms = 60_000, defaultAnswer = false }: ConfirmationOptions): Promise<boolean> {
+    if (defaultAnswer) throw new TypeError('Confirmation prompts require a false default answer.');
+
+    const controller = new AbortController();
+    const deadline = setTimeout(() => controller.abort(), ms);
+    try {
+      return await this.prompt({ message, default: false }, { signal: controller.signal });
+    } catch (error) {
+      if (
+        error instanceof Error &&
+        (error.name === 'ExitPromptError' || (error.name === 'AbortPromptError' && controller.signal.aborted))
+      ) {
+        return false;
+      }
+      throw error;
+    } finally {
+      clearTimeout(deadline);
+    }
+  }
+}
diff --git a/src/ux/flowVersionTable.ts b/src/ux/flowVersionTable.ts
new file mode 100644
index 0000000..171b778
--- /dev/null
+++ b/src/ux/flowVersionTable.ts
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { stripVTControlCharacters } from 'node:util';
+import { Ux } from '@salesforce/sf-plugins-core';
+
+/** Presentation values for the fields required by C1, not an assessment or count provider. */
+export type FlowVersionTableRow = {
+  versionName: string;
+  version: string;
+  status: string;
+  age: string;
+  creator: string;
+  createdDate: string;
+  lastModifiedDate: string;
+  references: string;
+  paused: string;
+  failed: string;
+  deletable: 'Yes' | 'No' | 'Error';
+  reason: string;
+};
+
+const fields = [
+  { key: 'versionName', name: 'Flow Version Name', width: 26 },
+  { key: 'version', name: 'Version', width: 9 },
+  { key: 'status', name: 'Status', width: 14 },
+  { key: 'age', name: 'Age', width: 7 },
+  { key: 'creator', name: 'Created By', width: 22 },
+  { key: 'createdDate', name: 'Created Date', width: 26 },
+  { key: 'lastModifiedDate', name: 'Last Modified Date', width: 26 },
+  { key: 'references', name: 'Referenced By', width: 15 },
+  { key: 'paused', name: 'Paused Interviews', width: 19 },
+  { key: 'failed', name: 'Failed Interviews', width: 19 },
+  { key: 'deletable', name: 'Deletable', width: 11 },
+  { key: 'reason', name: 'Reason' },
+] satisfies Array<{ key: keyof FlowVersionTableRow; name: string; width?: number }>;
+
+const safeText = (value: string): string => stripVTControlCharacters(value).replace(/[\p{Cc}\p{Cf}]/gu, ' ');
+
+const terminalWidth = (requestedWidth?: number): number => {
+  const override = Number.parseInt(process.env.OCLIF_TABLE_COLUMN_OVERRIDE ?? '', 10);
+  const width = requestedWidth ?? (override > 0 ? override : process.stdout.columns) ?? 160;
+  return Number.isFinite(width) && width > 0 ? Math.max(24, Math.floor(width)) : 160;
+};
+
+/** Uses the standard Salesforce CLI renderer and wraps every cell rather than dropping C1 information. */
+export const formatFlowVersionTable = (rows: FlowVersionTableRow[], requestedWidth?: number): string => {
+  if (rows.length === 0) return '';
+  const width = terminalWidth(requestedWidth);
+  const ux = new Ux({ jsonEnabled: false });
+  const data = rows.map((row) => Object.fromEntries(fields.map(({ key }) => [key, safeText(row[key])])));
+  if (width >= 260) {
+    return ux.makeTable({
+      data,
+      columns: fields.map((field) => ({ ...field, overflow: 'wrap' as const })),
+      maxWidth: width,
+      overflow: 'wrap',
+    });
+  }
+  return data
+    .map((row) =>
+      ux.makeTable({
+        data: fields.map(({ key, name }) => ({ field: name, value: row[key] })),
+        columns: [
+          { key: 'field', name: 'Field', width: Math.min(24, Math.floor(width / 2)), overflow: 'wrap' },
+          { key: 'value', name: 'Value', overflow: 'wrap' },
+        ],
+        maxWidth: width,
+        overflow: 'wrap',
+      })
+    )
+    .join('\n\n');
+};
diff --git a/src/ux/forceDeleteConfirmation.ts b/src/ux/forceDeleteConfirmation.ts
new file mode 100644
index 0000000..94b0671
--- /dev/null
+++ b/src/ux/forceDeleteConfirmation.ts
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import inquirerInput from '@inquirer/input';
+
+export type ForceDeleteInputPrompt = (
+  config: { message: string },
+  context: { signal: AbortSignal; clearPromptOnDone: true; output: NodeJS.WriteStream }
+) => Promise<string>;
+
+export type ForceDeleteConfirmationOptions = {
+  flowApiName: string;
+  versionNumber: number;
+  flowNameMessage: string;
+  versionMessage: string;
+  /** Human prompts can use stderr while the command reserves stdout for JSON. */
+  output?: NodeJS.WriteStream;
+  /** One shared deadline for both prompts. The caller may bound this by token expiry. */
+  ms?: number;
+};
+
+const requireInteractiveTerminal = (output: NodeJS.WriteStream): void => {
+  if (process.stdin.isTTY !== true || process.stdout.isTTY !== true || output.isTTY !== true) {
+    throw new TypeError('Force deletion requires interactive stdin, stdout and prompt output.');
+  }
+};
+
+const validateConfirmationValues = ({
+  flowApiName,
+  versionNumber,
+  flowNameMessage,
+  versionMessage,
+  ms,
+}: Required<Omit<ForceDeleteConfirmationOptions, 'output'>>): void => {
+  if (typeof flowApiName !== 'string' || !/^[A-Za-z][A-Za-z0-9_]{0,254}$/.test(flowApiName))
+    throw new TypeError('Confirmation requires a valid Flow API name.');
+  if (!Number.isSafeInteger(versionNumber) || versionNumber < 1)
+    throw new TypeError('Confirmation requires a positive version number.');
+  if (typeof flowNameMessage !== 'string' || typeof versionMessage !== 'string' || !flowNameMessage || !versionMessage)
+    throw new TypeError('Both confirmation prompt messages are required.');
+  if (!Number.isSafeInteger(ms) || ms <= 0 || ms > 2_147_483_647)
+    throw new TypeError('The confirmation deadline must be a positive supported number of milliseconds.');
+};
+
+/** Two exact typed values, without a default, persisted answers or non-interactive bypass. */
+export class ForceDeleteConfirmationPrompt {
+  public constructor(private readonly prompt: ForceDeleteInputPrompt = inquirerInput) {}
+
+  public async confirm({
+    flowApiName,
+    versionNumber,
+    flowNameMessage,
+    versionMessage,
+    output = process.stdout,
+    ms = 120_000,
+  }: ForceDeleteConfirmationOptions): Promise<boolean> {
+    requireInteractiveTerminal(output);
+    validateConfirmationValues({ flowApiName, versionNumber, flowNameMessage, versionMessage, ms });
+
+    const controller = new AbortController();
+    const deadline = setTimeout(() => controller.abort(), ms);
+    const context = { signal: controller.signal, clearPromptOnDone: true as const, output };
+    try {
+      const flowName = await this.prompt({ message: flowNameMessage }, context);
+      requireInteractiveTerminal(output);
+      if (controller.signal.aborted || flowName !== flowApiName) return false;
+      const version = await this.prompt({ message: versionMessage }, context);
+      requireInteractiveTerminal(output);
+      return !controller.signal.aborted && version === String(versionNumber);
+    } catch (error) {
+      if (
+        error instanceof Error &&
+        (error.name === 'ExitPromptError' || (error.name === 'AbortPromptError' && controller.signal.aborted))
+      )
+        return false;
+      throw error;
+    } finally {
+      clearTimeout(deadline);
+    }
+  }
+}
diff --git a/test/commands/flow/dependencies.test.ts b/test/commands/flow/dependencies.test.ts
new file mode 100644
index 0000000..8c32410
--- /dev/null
+++ b/test/commands/flow/dependencies.test.ts
@@ -0,0 +1,347 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { Org, SfError } from '@salesforce/core';
+import { stubSfCommandUx } from '@salesforce/sf-plugins-core';
+import Dependencies, {
+  formatDependencyReport,
+  type DependencyCommandReport,
+} from '../../../src/commands/flow/dependencies.js';
+import { DependencyService, type DependencyReport } from '../../../src/services/dependencyService.js';
+
+const reportFixture = (): DependencyReport => ({
+  generatedAt: '2026-10-21T00:00:00.000Z',
+  root: {
+    flowName: 'Child',
+    namespace: null,
+    definitionId: '300xx000000bojNAAQ',
+    versionId: '301xx000003Ga19AAC',
+    versionNumber: 1,
+    status: 'Draft',
+  },
+  versionPolicy: 'latest',
+  scannedFlows: [],
+  relationships: [
+    {
+      direction: 'incoming',
+      callerType: 'Flow',
+      callerName: 'Parent',
+      callerVersion: 1,
+      callerStatus: 'Draft',
+      targetType: 'FlowDefinition',
+      targetName: 'Child',
+      elementName: 'Call_Child',
+      evidence: 'Flow.Metadata',
+    },
+  ],
+  mcd: { status: 'success', reportedEdges: [], queryCount: 4, limit: 200 },
+  warnings: ['Empty dependency-API results do not prove no references.'],
+  scope: {
+    flowMetadata: 'explicit-flows-only',
+    requestedFlowNames: ['Child', 'Parent'],
+    orgWideComplete: false,
+    apexSourceScanned: false,
+  },
+});
+
+describe('flow dependencies command', () => {
+  const sandbox = sinon.createSandbox();
+  let analyze: sinon.SinonStub;
+  let log: sinon.SinonStub;
+  let logJson: sinon.SinonStub;
+  let logToStderr: sinon.SinonStub;
+  let report: DependencyReport;
+  let originalExitCode: typeof process.exitCode;
+
+  beforeEach(() => {
+    originalExitCode = process.exitCode;
+    report = reportFixture();
+    report.scannedFlows = [report.root];
+    const ux = stubSfCommandUx(sandbox);
+    log = ux.log;
+    logJson = ux.logJson;
+    logToStderr = ux.logToStderr;
+    sandbox.stub(Org, 'create').resolves({
+      getConnection: () => ({ getApiVersion: () => '67.0', tooling: {} }),
+      getUsername: () => 'poc@example.com',
+    } as unknown as Org);
+    analyze = sandbox.stub(DependencyService.prototype, 'analyze').resolves(report);
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+    process.exitCode = originalExitCode;
+  });
+
+  it('passes the explicit scope and version policy to the service and displays evidence', async () => {
+    const result = await Dependencies.run([
+      '-o',
+      'source',
+      '-f',
+      'Child',
+      '--scan-flow',
+      'Parent',
+      '--version-policy',
+      'latest',
+      '--api-version',
+      '67.0',
+    ]);
+    expect(analyze.calledOnce).to.equal(true);
+    expect(analyze.firstCall.args[0]).to.deep.equal({
+      flowName: 'Child',
+      namespace: undefined,
+      scanFlows: ['Parent'],
+      versionPolicy: 'latest',
+    });
+    expect(result.root).to.deep.equal(report.root);
+    expect(log.firstCall.args[0]).to.include('Evidence: Flow.Metadata | Element: Call_Child');
+    expect(String(log.firstCall.args[0]).trimStart().split('\n')[0]).to.equal('=== Flow dependencies');
+    expect(log.firstCall.args[0]).to.include('Target org: poc@example.com | API: 67.0 | Version policy: latest');
+  });
+
+  it('passes arbitrary names, namespace, and repeated caller flags unchanged and renders service-provided names', async () => {
+    report.root = {
+      ...report.root,
+      flowName: 'Invoice_Approval',
+      namespace: 'billing',
+      versionNumber: 4,
+      status: 'Active',
+    };
+    report.versionPolicy = 'active';
+    report.relationships = [
+      {
+        direction: 'incoming',
+        callerType: 'Flow',
+        callerName: 'billing__Receipt_Reconciliation',
+        callerVersion: 7,
+        callerStatus: 'Active',
+        targetType: 'FlowDefinition',
+        targetName: 'billing__Invoice_Approval',
+        elementName: 'Approve_Invoice',
+        evidence: 'Flow.Metadata',
+      },
+      {
+        direction: 'incoming',
+        callerType: 'Flow',
+        callerName: 'billing__Refund_Request',
+        callerVersion: 3,
+        callerStatus: 'Draft',
+        targetType: 'FlowDefinition',
+        targetName: 'billing__Invoice_Approval',
+        elementName: 'Check_Invoice',
+        evidence: 'Flow.Metadata',
+      },
+    ];
+    report.scannedFlows = [report.root];
+    report.scope.requestedFlowNames = ['Invoice_Approval', 'Receipt_Reconciliation', 'Refund_Request'];
+
+    const result = await Dependencies.run([
+      '-o',
+      'source',
+      '--flow-name',
+      'Invoice_Approval',
+      '--namespace',
+      'billing',
+      '--scan-flow',
+      'Receipt_Reconciliation',
+      '--scan-flow',
+      'Refund_Request',
+      '--scan-flow',
+      'Receipt_Reconciliation',
+      '--version-policy',
+      'active',
+    ]);
+
+    expect(analyze.calledOnce).to.equal(true);
+    expect(analyze.firstCall.args[0]).to.deep.equal({
+      flowName: 'Invoice_Approval',
+      namespace: 'billing',
+      scanFlows: ['Receipt_Reconciliation', 'Refund_Request', 'Receipt_Reconciliation'],
+      versionPolicy: 'active',
+    });
+    expect(result.root).to.deep.equal(report.root);
+    expect(result.relationships).to.deep.equal(report.relationships);
+    const output = String(log.firstCall.args[0]);
+    expect(output).to.include('Root: Invoice_Approval (v4, Active)');
+    expect(output).to.include('Flow: billing__Receipt_Reconciliation (v7, Active)');
+    expect(output).to.include('Flow: billing__Refund_Request (v3, Draft)');
+    expect(output).to.include('-> FlowDefinition: billing__Invoice_Approval');
+    expect(output).to.include('Evidence: Flow.Metadata | Element: Approve_Invoice');
+    expect(output).not.to.include('FlowDependency_POC_');
+    expect(output).not.to.include('Root: Child');
+    expect(output).not.to.include('Flow: Parent');
+  });
+
+  it('retains all structured scope, warnings, and dependency evidence in JSON without human output', async () => {
+    report.mcd.status = 'partial';
+    report.mcd.reportedEdges = [
+      {
+        MetadataComponentId: '01pxx000000AbCdAAK',
+        MetadataComponentName: 'CallsChild',
+        MetadataComponentType: 'ApexClass',
+        MetadataComponentNamespace: null,
+        RefMetadataComponentId: report.root.definitionId,
+        RefMetadataComponentName: 'Child',
+        RefMetadataComponentType: 'FlowDefinition',
+        RefMetadataComponentNamespace: null,
+      },
+    ];
+    report.warnings.push('One dependency query was incomplete; Apex source was not scanned.');
+    const result = await Dependencies.run(['-o', 'source', '-f', 'Child', '--json']);
+
+    expect(result).to.deep.equal({ ...report, targetOrg: 'poc@example.com', apiVersion: '67.0' });
+    expect(result.scope).to.deep.equal({
+      flowMetadata: 'explicit-flows-only',
+      requestedFlowNames: ['Child', 'Parent'],
+      orgWideComplete: false,
+      apexSourceScanned: false,
+    });
+    expect(result.scannedFlows).to.deep.equal([report.root]);
+    expect(result.warnings).to.deep.equal(report.warnings);
+    expect(result.mcd).to.deep.equal(report.mcd);
+    expect(log.called).to.equal(false);
+    expect(logToStderr.called).to.equal(false);
+    expect(logJson.calledOnce).to.equal(true);
+  });
+
+  it('surrounds human errors with stderr blank lines while preserving the required-read error and exit code', async () => {
+    analyze.rejects(new SfError('Flow was not readable.', 'FlowReadFailure', undefined, 7));
+    try {
+      await Dependencies.run(['-o', 'source', '-f', 'Missing']);
+      expect.fail('Expected a required-read error.');
+    } catch (error) {
+      expect((error as Error).message).to.include('Flow was not readable.');
+      expect((error as SfError).exitCode).to.equal(7);
+    }
+    expect(log.called).to.equal(false);
+    expect(logJson.called).to.equal(false);
+    expect(logToStderr.callCount).to.equal(3);
+    expect(logToStderr.firstCall.args).to.deep.equal(['']);
+    expect(logToStderr.secondCall.args[0]).to.include('Flow was not readable.');
+    expect(logToStderr.thirdCall.args).to.deep.equal(['']);
+    expect(process.exitCode).to.equal(7);
+  });
+
+  it('returns a JSON error without human whitespace or stderr and preserves the error code', async () => {
+    analyze.rejects(new SfError('Flow was not readable.', 'FlowReadFailure', undefined, 7));
+    try {
+      await Dependencies.run(['-o', 'source', '-f', 'Missing', '--json']);
+      expect.fail('Expected a JSON required-read error.');
+    } catch (error) {
+      expect((error as Error).message).to.include('Flow was not readable.');
+      expect((error as SfError).exitCode).to.equal(7);
+    }
+
+    expect(log.called).to.equal(false);
+    expect(logToStderr.called).to.equal(false);
+    expect(logJson.calledOnce).to.equal(true);
+    expect(logJson.firstCall.args[0]).to.include({
+      name: 'FlowReadFailure',
+      message: 'Flow was not readable.',
+      exitCode: 7,
+      status: 7,
+    });
+    expect(process.exitCode).to.equal(7);
+  });
+
+  it('rejects an unsupported version policy before analyzing', async () => {
+    try {
+      await Dependencies.run(['-o', 'source', '-f', 'Child', '--version-policy', 'all']);
+      expect.fail('Expected flag validation to fail.');
+    } catch (error) {
+      expect((error as Error).message).to.include('all');
+    }
+    expect(analyze.called).to.equal(false);
+  });
+
+  it('renders exactly the compact human report with a metadata-confirmed incoming relationship', () => {
+    const text = formatDependencyReport({ ...report, targetOrg: 'source', apiVersion: '67.0' });
+    expect(text).to.equal(
+      [
+        '',
+        '=== Flow dependencies',
+        'Target org: source | API: 67.0 | Version policy: latest',
+        'Root: Child (v1, Draft)',
+        'Definition: 300xx000000bojNAAQ | Version: 301xx000003Ga19AAC',
+        '',
+        '=== Incoming references',
+        '  Flow: Parent (v1, Draft)',
+        '    -> FlowDefinition: Child',
+        '    Evidence: Flow.Metadata | Element: Call_Child',
+        '',
+        '=== Outgoing dependencies',
+        '  None reported within the inspected providers and scan scope.',
+        '',
+      ].join('\n')
+    );
+  });
+
+  it('adds exactly one newline before and after human report content', () => {
+    const text = formatDependencyReport({ ...report, targetOrg: 'source', apiVersion: '67.0' });
+
+    expect(text.startsWith('\n=== Flow dependencies\n')).to.equal(true);
+    expect(text.endsWith('\n')).to.equal(true);
+    expect(text.startsWith('\n\n')).to.equal(false);
+    expect(text.endsWith('\n\n')).to.equal(false);
+  });
+
+  it('omits the scan list and diagnostic footer from human output without mutating the full report', () => {
+    const fullReport = { ...report, targetOrg: 'source', apiVersion: '67.0' };
+    const original = JSON.parse(JSON.stringify(fullReport)) as DependencyCommandReport;
+    const text = formatDependencyReport(fullReport);
+
+    for (const omitted of [
+      '(read-only)',
+      'Scan scope:',
+      'explicitly selected Flow version(s)',
+      'NOT an org-wide impact report',
+      'Dependency API:',
+      'distinct row(s)',
+      'Apex source analysis:',
+      '=== Coverage notes',
+      'No deployment, activation, Flow execution, or deletion was performed.',
+      ...report.warnings,
+    ]) {
+      expect(text).not.to.include(omitted);
+    }
+    expect(fullReport).to.deep.equal(original);
+  });
+
+  it('displays outgoing relationships and an empty scoped incoming section in the compact format', () => {
+    report.relationships[0].direction = 'outgoing';
+    const text = formatDependencyReport({ ...report, targetOrg: 'source', apiVersion: '67.0' });
+
+    expect(text).to.include('=== Incoming references\n  None reported within the inspected providers and scan scope.');
+    expect(text).to.include(
+      [
+        '=== Outgoing dependencies',
+        '  Flow: Parent (v1, Draft)',
+        '    -> FlowDefinition: Child',
+        '    Evidence: Flow.Metadata | Element: Call_Child',
+      ].join('\n')
+    );
+  });
+
+  it('removes terminal control sequences from returned metadata text', () => {
+    const unsafe: DependencyCommandReport = { ...report, targetOrg: 'source', apiVersion: '67.0' };
+    unsafe.relationships[0].callerName = 'Parent\u001b[31m\nInjected';
+    const text = formatDependencyReport(unsafe);
+    expect(text).not.to.include('\u001b');
+    expect(text).to.include('Parent [31m Injected');
+  });
+});
diff --git a/test/commands/flow/version/delete.test.ts b/test/commands/flow/version/delete.test.ts
new file mode 100644
index 0000000..0787fb6
--- /dev/null
+++ b/test/commands/flow/version/delete.test.ts
@@ -0,0 +1,1012 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { fileURLToPath } from 'node:url';
+import { readFileSync } from 'node:fs';
+import Ajv from 'ajv';
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { run as runCli } from '@oclif/core';
+import { Org, SfError } from '@salesforce/core';
+import {
+  FlowVersionDeleteService,
+  FlowVersionError,
+  type FlowVersionDeleteExecutionReport,
+  type FlowVersionDeletePlan,
+  type FlowVersionDeleteTarget,
+} from '@salesforce/flow-node';
+import { stubSfCommandUx } from '@salesforce/sf-plugins-core';
+import FlowVersionDelete, {
+  formatVersionDeleteReport,
+  type FlowVersionDeleteCommandReport,
+} from '../../../../src/commands/flow/version/delete.js';
+import { ConfirmationPrompt } from '../../../../src/ux/confirmation.js';
+
+const runNormal = async (args: string[]): Promise<FlowVersionDeleteCommandReport> => {
+  const result = await FlowVersionDelete.run(args);
+  if (result.mode !== 'NORMAL') throw new Error('A normal deletion command routed to force mode.');
+  return result;
+};
+
+const schema = JSON.parse(
+  readFileSync(new URL('../../../../schemas/flow-version-delete.json', import.meta.url), 'utf8')
+) as object;
+const validateReport = new Ajv({ allErrors: true }).compile(schema);
+
+const planFixture = (): FlowVersionDeletePlan => ({
+  contractVersion: '2',
+  orgId: '00D000000000001EAA',
+  flowName: 'Invoice_Approval',
+  namespace: null,
+  definitionId: '300xx000000bojNAAQ',
+  requestedVersions: [2],
+  versions: [
+    {
+      definitionId: '300xx000000bojNAAQ',
+      versionId: '301xx000003Ga19AAC',
+      flowName: 'Invoice_Approval',
+      namespace: null,
+      versionNumber: 2,
+      status: 'Draft',
+      assessment: {
+        versionId: '301xx000003Ga19AAC',
+        outcome: 'PASS',
+        reasonCode: null,
+        message: null,
+        evidence: [],
+      },
+      error: null,
+    },
+  ],
+  availableVersionCount: 3,
+  warnings: ['Client selection checks are not atomic.'],
+});
+
+const deletionFixture = (plan: FlowVersionDeletePlan): FlowVersionDeleteExecutionReport => ({
+  contractVersion: '2',
+  mode: 'NORMAL',
+  orgId: plan.orgId,
+  flowName: plan.flowName,
+  namespace: plan.namespace,
+  definitionId: plan.definitionId,
+  outcome: 'SUCCEEDED',
+  results: plan.versions.map((version) => ({
+    ...version,
+    state: 'SUCCEEDED',
+    targetDeleted: true,
+    source: 'TOOLING',
+    error: null,
+  })),
+  warnings: [],
+});
+
+const commandReportFixture = (plan = planFixture()): FlowVersionDeleteCommandReport => ({
+  contractVersion: '2',
+  mode: 'NORMAL',
+  targetOrg: 'poc@example.com',
+  apiVersion: '67.0',
+  dryRun: false,
+  confirmed: false,
+  outcome: 'PREVIEWED',
+  plan,
+  deletion: null,
+});
+
+const targetFixture = (versionNumber: number): FlowVersionDeleteTarget => {
+  const versionId = `30100000000000${versionNumber}AAA`;
+  return {
+    definitionId: '300xx000000bojNAAQ',
+    versionId,
+    flowName: 'Invoice_Approval',
+    namespace: null,
+    versionNumber,
+    status: versionNumber === 2 ? 'Active' : 'Draft',
+    assessment: { versionId, outcome: 'PASS', reasonCode: null, message: null, evidence: [] },
+    error: null,
+  };
+};
+
+const blockTarget = (target: FlowVersionDeleteTarget, reasonCode: string, message = reasonCode): void => {
+  Object.assign(target, {
+    assessment: { versionId: target.versionId!, outcome: 'BLOCKED', reasonCode, message, evidence: [] },
+  });
+};
+
+describe('flow version delete command', () => {
+  const sandbox = sinon.createSandbox();
+  const args = ['--target-org', 'source', '--flow', 'Invoice_Approval', '--versions', '2'];
+  let plan: FlowVersionDeletePlan;
+  let deletion: FlowVersionDeleteExecutionReport;
+  let planStub: sinon.SinonStub;
+  let execute: sinon.SinonStub;
+  let log: sinon.SinonStub;
+  let logJson: sinon.SinonStub;
+  let logToStderr: sinon.SinonStub;
+  let confirm: sinon.SinonStub;
+  let createOrg: sinon.SinonStub;
+  let getConnection: sinon.SinonStub;
+  let originalExitCode: typeof process.exitCode;
+  let originalIsTTY: PropertyDescriptor | undefined;
+
+  const setInteractive = (interactive: boolean): void => {
+    Object.defineProperty(process.stdin, 'isTTY', { configurable: true, value: interactive });
+  };
+
+  const expectError = async (commandArgs: string[], fragment?: string): Promise<Error> => {
+    let caught: unknown;
+    try {
+      await runNormal(commandArgs);
+    } catch (error) {
+      caught = error;
+    }
+    expect(caught).to.be.instanceOf(Error);
+    if (fragment) expect((caught as Error).message).to.include(fragment);
+    return caught as Error;
+  };
+
+  beforeEach(() => {
+    originalExitCode = process.exitCode;
+    originalIsTTY = Object.getOwnPropertyDescriptor(process.stdin, 'isTTY');
+    process.exitCode = undefined;
+    setInteractive(false);
+    plan = planFixture();
+    deletion = deletionFixture(plan);
+    const ux = stubSfCommandUx(sandbox);
+    log = ux.log;
+    logJson = ux.logJson;
+    logToStderr = ux.logToStderr;
+    confirm = sandbox.stub(ConfirmationPrompt.prototype, 'confirm').resolves(false);
+    getConnection = sandbox.stub().returns({
+      getApiVersion: () => '67.0',
+      getAuthInfoFields: () => ({ orgId: '00D000000000001EAA' }),
+      tooling: { query: sandbox.stub(), queryMore: sandbox.stub() },
+      request: sandbox.stub(),
+    });
+    createOrg = sandbox.stub(Org, 'create').resolves({
+      getConnection,
+      getUsername: () => 'poc@example.com',
+    } as unknown as Org);
+    planStub = sandbox.stub(FlowVersionDeleteService.prototype, 'plan').resolves(plan);
+    execute = sandbox.stub(FlowVersionDeleteService.prototype, 'execute').resolves(deletion);
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+    process.exitCode = originalExitCode;
+    if (originalIsTTY) Object.defineProperty(process.stdin, 'isTTY', originalIsTTY);
+    else Reflect.deleteProperty(process.stdin, 'isTTY');
+  });
+
+  it('forwards arbitrary Flow names, namespaces, version expressions and API version without hardcoded selection', async () => {
+    plan.flowName = 'Receipt_Reconciliation';
+    plan.namespace = 'billing';
+    const result = await runNormal([
+      '-o',
+      'source',
+      '-f',
+      'Receipt_Reconciliation',
+      '--namespace',
+      'billing',
+      '--versions',
+      '2,4-6',
+      '--api-version',
+      '67.0',
+      '--dry-run',
+    ]);
+
+    expect(planStub.calledOnce).to.equal(true);
+    expect(planStub.firstCall.args).to.deep.equal([
+      { flowName: 'Receipt_Reconciliation', namespace: 'billing', versions: '2,4-6' },
+    ]);
+    expect(getConnection.calledOnceWithExactly('67.0')).to.equal(true);
+    expect(result.plan).to.equal(plan);
+    expect(String(log.firstCall.args[0])).to.include('Flow: billing__Receipt_Reconciliation');
+    expect(execute.called).to.equal(false);
+  });
+
+  it('allows a noninteractive dry run without confirmation and sends no mutation', async () => {
+    const result = await runNormal([...args, '--dry-run']);
+
+    expect(result).to.deep.equal({ ...commandReportFixture(plan), dryRun: true });
+    expect(planStub.calledOnce).to.equal(true);
+    expect(confirm.called).to.equal(false);
+    expect(execute.called).to.equal(false);
+    expect(log.calledOnce).to.equal(true);
+    expect(String(log.firstCall.args[0])).to.include('No deletion requests were sent');
+    expect(process.exitCode).not.to.equal(1);
+  });
+
+  it('returns the full dry-run plan as JSON without a prompt or human output', async () => {
+    const result = await runNormal([...args, '--dry-run', '--json']);
+
+    expect(result.plan).to.deep.equal(plan);
+    expect(result.deletion).to.equal(null);
+    expect(result.outcome).to.equal('PREVIEWED');
+    expect(result.confirmed).to.equal(false);
+    expect(confirm.called).to.equal(false);
+    expect(execute.called).to.equal(false);
+    expect(log.called).to.equal(false);
+    expect(logToStderr.called).to.equal(false);
+    expect(logJson.calledOnce).to.equal(true);
+  });
+
+  it('rejects noninteractive mutation without --yes before planning or executing', async () => {
+    await expectError(args, 'requires --yes');
+
+    expect(planStub.called).to.equal(false);
+    expect(execute.called).to.equal(false);
+    expect(confirm.called).to.equal(false);
+    expect(getConnection.called).to.equal(false);
+  });
+
+  it('rejects JSON mutation without --yes even when stdin is interactive', async () => {
+    setInteractive(true);
+    await expectError([...args, '--json'], 'requires --yes');
+
+    expect(planStub.called).to.equal(false);
+    expect(execute.called).to.equal(false);
+    expect(confirm.called).to.equal(false);
+    expect(log.called).to.equal(false);
+    expect(logToStderr.called).to.equal(false);
+    expect(logJson.calledOnce).to.equal(true);
+  });
+
+  it('displays the exact plan before prompting, defaults to no and cancels without mutation', async () => {
+    setInteractive(true);
+    const result = await runNormal(args);
+
+    expect(result.outcome).to.equal('CANCELLED');
+    expect(result.confirmed).to.equal(false);
+    expect(result.deletion).to.equal(null);
+    expect(log.calledBefore(confirm)).to.equal(true);
+    expect(String(log.firstCall.args[0])).to.include('v2 | 301xx000003Ga19AAC | Draft');
+    expect(confirm.calledOnce).to.equal(true);
+    expect(confirm.firstCall.args[0]).to.include({ defaultAnswer: false });
+    expect((confirm.firstCall.args[0] as { message: string }).message).to.include('1 requested Flow versions');
+    expect(execute.called).to.equal(false);
+    expect(String(log.lastCall.args[0])).to.include('Deletion cancelled');
+  });
+
+  it('allows one minute for standard-flag confirmation and cancels when the prompt times out unanswered', async () => {
+    setInteractive(true);
+    confirm.resolves(false);
+
+    const result = await runNormal(args);
+
+    expect(confirm.calledOnce).to.equal(true);
+    expect(confirm.firstCall.args[0]).to.include({ ms: 60_000, defaultAnswer: false });
+    expect(result.outcome).to.equal('CANCELLED');
+    expect(result.confirmed).to.equal(false);
+    expect(result.deletion).to.equal(null);
+    expect(execute.called).to.equal(false);
+    expect(String(log.lastCall.args[0])).to.include('Deletion cancelled');
+  });
+
+  it('executes the same displayed plan after explicit interactive confirmation', async () => {
+    setInteractive(true);
+    confirm.resolves(true);
+    const result = await runNormal(args);
+
+    expect(execute.calledOnce).to.equal(true);
+    expect(execute.firstCall.args[0]).to.equal(plan);
+    expect(confirm.calledBefore(execute)).to.equal(true);
+    expect(result.confirmed).to.equal(true);
+    expect(result.deletion).to.equal(deletion);
+    expect(result.outcome).to.equal('SUCCEEDED');
+    expect(log.callCount).to.equal(2);
+  });
+
+  it('uses --yes to approve exactly the resolved plan without prompting', async () => {
+    const result = await runNormal([...args, '--yes']);
+
+    expect(planStub.calledOnce).to.equal(true);
+    expect(confirm.called).to.equal(false);
+    expect(execute.calledOnce).to.equal(true);
+    expect(execute.firstCall.args[0]).to.equal(plan);
+    expect(result).to.deep.equal({
+      ...commandReportFixture(plan),
+      confirmed: true,
+      outcome: 'SUCCEEDED',
+      deletion,
+    });
+    expect(String(log.firstCall.args[0])).to.include('=== Results');
+    expect(String(log.firstCall.args[0])).to.include('v2 | 301xx000003Ga19AAC | SUCCEEDED');
+  });
+
+  it('returns successful JSON deletion results without human output', async () => {
+    const result = await runNormal([...args, '--yes', '--json']);
+
+    expect(result.deletion).to.deep.equal(deletion);
+    expect(result.confirmed).to.equal(true);
+    expect(log.called).to.equal(false);
+    expect(logToStderr.called).to.equal(false);
+    expect(confirm.called).to.equal(false);
+    expect(logJson.calledOnce).to.equal(true);
+  });
+
+  it('preserves a partial SDK result in JSON and sets a nonzero exit code', async () => {
+    deletion.outcome = 'PARTIAL';
+    deletion.results[0].state = 'BLOCKED';
+    deletion.results[0].targetDeleted = false;
+    deletion.results[0].source = 'ASSESSMENT';
+    deletion.results[0].error = { code: 'ACTIVE_VERSION', message: 'ACTIVE_VERSION' };
+    const result = await runNormal([...args, '--yes', '--json']);
+
+    expect(result.outcome).to.equal('PARTIAL');
+    expect(result.deletion).to.deep.equal(deletion);
+    expect(process.exitCode).to.equal(1);
+    expect(log.called).to.equal(false);
+    expect(logJson.calledOnce).to.equal(true);
+    expect(execute.calledOnce).to.equal(true);
+  });
+
+  it('preserves an unknown SDK outcome in JSON and does not retry execution', async () => {
+    deletion.outcome = 'UNKNOWN';
+    deletion.results[0].state = 'UNKNOWN';
+    deletion.results[0].targetDeleted = null;
+    deletion.results[0].source = 'TOOLING';
+    deletion.results[0].error = {
+      code: 'DELETE_OUTCOME_UNCONFIRMED',
+      message: 'The deletion outcome is not confirmed.',
+    };
+    const result = await runNormal([...args, '--yes', '--json']);
+
+    expect(result.outcome).to.equal('UNKNOWN');
+    expect(result.deletion).to.deep.equal(deletion);
+    expect(process.exitCode).to.equal(2);
+    expect(execute.calledOnce).to.equal(true);
+    expect(log.called).to.equal(false);
+    expect(logJson.calledOnce).to.equal(true);
+  });
+
+  it('never executes or prompts when the whole assessment request fails', async () => {
+    planStub.rejects(new SfError('Unable to complete the assessment request.', 'ASSESSMENT_REQUEST_FAILED'));
+    await expectError([...args, '--yes'], 'Unable to complete the assessment request');
+
+    expect(execute.called).to.equal(false);
+    expect(confirm.called).to.equal(false);
+  });
+
+  it('does not retry when execution raises an unexpected error', async () => {
+    execute.rejects(new SfError('Unable to determine deletion outcome.', 'UnexpectedExecutionError'));
+    await expectError([...args, '--yes'], 'Unable to determine deletion outcome');
+
+    expect(execute.calledOnce).to.equal(true);
+    expect(confirm.called).to.equal(false);
+  });
+
+  it('returns mixed C2 results without dropping blocked versions or later successes', async () => {
+    plan.requestedVersions = [1, 2, 3];
+    plan.versions = [1, 2, 3].map(targetFixture);
+    blockTarget(plan.versions[0], 'PAUSED_INTERVIEWS', 'PAUSED_INTERVIEWS (1)');
+    blockTarget(plan.versions[1], 'ACTIVE_VERSION');
+    deletion = deletionFixture(plan);
+    deletion.outcome = 'PARTIAL';
+    deletion.results = plan.versions.map((target) =>
+      target.assessment?.outcome === 'BLOCKED'
+        ? {
+            ...target,
+            state: 'BLOCKED',
+            targetDeleted: false,
+            source: 'ASSESSMENT',
+            error: { code: target.assessment.reasonCode!, message: target.assessment.message! },
+          }
+        : { ...target, state: 'SUCCEEDED', targetDeleted: true, source: 'TOOLING', error: null }
+    );
+    execute.resolves(deletion);
+
+    const result = await runNormal([
+      '-o',
+      'source',
+      '--flow',
+      'Invoice_Approval',
+      '--versions',
+      '1-3',
+      '--yes',
+      '--json',
+    ]);
+
+    expect(result.deletion?.results.map((item) => item.state)).to.deep.equal(['BLOCKED', 'BLOCKED', 'SUCCEEDED']);
+    expect(result.deletion?.results[0].error?.message).to.equal('PAUSED_INTERVIEWS (1)');
+    expect(process.exitCode).to.equal(1);
+    expect(validateReport(result), JSON.stringify(validateReport.errors)).to.equal(true);
+    expect(execute.calledOnceWithExactly(plan)).to.equal(true);
+    expect(confirm.called).to.equal(false);
+  });
+
+  it('retains a missing version as a failed item alongside a successful version', async () => {
+    const missing = targetFixture(8);
+    Object.assign(missing, {
+      versionId: null,
+      status: null,
+      assessment: null,
+      error: { code: 'VERSION_NOT_FOUND', message: 'Version 8 does not exist in this Flow.' },
+    });
+    plan.requestedVersions = [2, 8];
+    plan.versions.push(missing);
+    deletion = deletionFixture(plan);
+    deletion.outcome = 'PARTIAL';
+    Object.assign(deletion.results[1], {
+      state: 'FAILED',
+      source: 'RESOLUTION',
+      targetDeleted: false,
+      error: missing.error,
+    });
+    execute.resolves(deletion);
+
+    const result = await runNormal([...args, '--yes', '--json']);
+
+    expect(result.deletion?.results.map((item) => item.state)).to.deep.equal(['SUCCEEDED', 'FAILED']);
+    expect(result.deletion?.results[1].versionId).to.equal(null);
+    expect(process.exitCode).to.equal(2);
+    expect(validateReport(result), JSON.stringify(validateReport.errors)).to.equal(true);
+  });
+
+  it('keeps an assessment ERROR distinct from a business blocker', async () => {
+    const target = plan.versions[0];
+    target.assessment = {
+      versionId: target.versionId!,
+      outcome: 'ERROR',
+      reasonCode: 'OPERATIONAL',
+      message: null,
+      evidence: [],
+    };
+    deletion = deletionFixture(plan);
+    deletion.outcome = 'FAILED';
+    Object.assign(deletion.results[0], {
+      state: 'FAILED',
+      source: 'ASSESSMENT',
+      targetDeleted: false,
+      error: { code: 'OPERATIONAL', message: 'The version was not assessed.' },
+    });
+    execute.resolves(deletion);
+
+    const result = await runNormal([...args, '--yes']);
+
+    expect(process.exitCode).to.equal(2);
+    expect(result.deletion?.results[0].state).to.equal('FAILED');
+    expect(String(log.firstCall.args[0])).to.include('OPERATIONAL');
+    expect(String(log.firstCall.args[0])).not.to.include('| BLOCKED');
+  });
+
+  it('completes a dry run with blocked and unresolved items without confirmation or deletion', async () => {
+    blockTarget(plan.versions[0], 'ACTIVE_VERSION');
+    const missing = targetFixture(9);
+    Object.assign(missing, {
+      versionId: null,
+      status: null,
+      assessment: null,
+      error: { code: 'VERSION_NOT_FOUND', message: 'Version 9 is missing.' },
+    });
+    plan.requestedVersions.push(9);
+    plan.versions.push(missing);
+
+    const result = await runNormal([...args, '--dry-run', '--json']);
+
+    expect(result.plan.versions[0].assessment?.outcome).to.equal('BLOCKED');
+    expect(result.plan.versions[1].versionId).to.equal(null);
+    expect(result.outcome).to.equal('PREVIEWED');
+    expect(process.exitCode).to.equal(undefined);
+    expect(execute.called).to.equal(false);
+    expect(confirm.called).to.equal(false);
+    expect(validateReport(result), JSON.stringify(validateReport.errors)).to.equal(true);
+  });
+
+  it('gives failed results precedence over blocked results for the process exit code', async () => {
+    plan.requestedVersions = [1, 2];
+    plan.versions = [1, 2].map(targetFixture);
+    deletion = deletionFixture(plan);
+    deletion.outcome = 'FAILED';
+    Object.assign(deletion.results[0], {
+      state: 'BLOCKED',
+      source: 'ASSESSMENT',
+      targetDeleted: false,
+      error: { code: 'ACTIVE_VERSION', message: 'ACTIVE_VERSION' },
+    });
+    Object.assign(deletion.results[1], {
+      state: 'FAILED',
+      source: 'TOOLING',
+      targetDeleted: false,
+      error: { code: 'DELETE_FAILED', message: 'The platform rejected deletion.' },
+    });
+    execute.resolves(deletion);
+
+    const result = await runNormal([...args, '--yes', '--json']);
+
+    expect(process.exitCode).to.equal(2);
+    expect(result.deletion?.results.map((item) => item.state)).to.deep.equal(['BLOCKED', 'FAILED']);
+  });
+
+  it('preserves unknown and not-attempted items rather than claiming a confirmed failure', async () => {
+    plan.requestedVersions = [1, 2];
+    plan.versions = [1, 2].map(targetFixture);
+    deletion = deletionFixture(plan);
+    deletion.outcome = 'UNKNOWN';
+    Object.assign(deletion.results[0], {
+      state: 'UNKNOWN',
+      source: 'TOOLING',
+      targetDeleted: null,
+      error: { code: 'DELETE_OUTCOME_UNCONFIRMED', message: 'The response was lost.' },
+    });
+    Object.assign(deletion.results[1], {
+      state: 'NOT_ATTEMPTED',
+      source: 'SAFETY',
+      targetDeleted: null,
+      error: { code: 'EXECUTION_STOPPED', message: 'An earlier outcome needs reconciliation.' },
+    });
+    execute.resolves(deletion);
+
+    const result = await runNormal([...args, '--yes', '--json']);
+
+    expect(process.exitCode).to.equal(2);
+    expect(result.deletion?.results.every((item) => item.targetDeleted === null)).to.equal(true);
+    expect(execute.calledOnce).to.equal(true);
+    expect(validateReport(result), JSON.stringify(validateReport.errors)).to.equal(true);
+  });
+
+  it('maps SDK errors to typed Salesforce CLI errors', async () => {
+    planStub.rejects(new FlowVersionError('ASSESSMENT_API_VERSION_UNSUPPORTED', 'API 67.0 or later is required.'));
+
+    const error = await expectError([...args, '--dry-run'], 'API 67.0');
+
+    expect(error).to.be.instanceOf(SfError);
+    expect((error as SfError).code).to.equal('ASSESSMENT_API_VERSION_UNSUPPORTED');
+    expect(execute.called).to.equal(false);
+  });
+
+  it('does not route headless force execution through normal planning or mutation', async () => {
+    await expectError([...args, '--yes', '--force'], 'interactive input and output');
+
+    expect(planStub.called).to.equal(false);
+    expect(execute.called).to.equal(false);
+  });
+
+  it('requires an explicit Flow name and explicit version selection', async () => {
+    await expectError(['-o', 'source', '--versions', '2', '--dry-run'], 'flow');
+    await expectError(['-o', 'source', '--flow', 'Invoice_Approval', '--dry-run'], 'versions');
+
+    expect(planStub.called).to.equal(false);
+    expect(execute.called).to.equal(false);
+  });
+
+  describe('bare named arguments', () => {
+    const bareArgs = ['target-org', 'source', 'flow', 'Invoice_Approval', 'versions', '2'];
+
+    it('passes the same requested Flow and comma-separated versions as standard flags', async () => {
+      const bareResult = await runNormal(['target-org', 'source', 'flow', 'MyFlow1', 'versions', '1,2,3', '--dry-run']);
+      const flaggedResult = await runNormal([
+        '--target-org',
+        'source',
+        '--flow',
+        'MyFlow1',
+        '--versions',
+        '1,2,3',
+        '--dry-run',
+      ]);
+
+      expect(planStub.callCount).to.equal(2);
+      for (const call of planStub.getCalls()) {
+        expect(call.args).to.deep.equal([{ flowName: 'MyFlow1', versions: '1,2,3', namespace: undefined }]);
+      }
+      expect(createOrg.calledWithExactly({ aliasOrUsername: 'source' })).to.equal(true);
+      expect(bareResult).to.deep.equal(flaggedResult);
+      expect(bareResult.dryRun).to.equal(true);
+      expect(bareResult.outcome).to.equal('PREVIEWED');
+      expect(confirm.called).to.equal(false);
+      expect(execute.called).to.equal(false);
+    });
+
+    it('preserves native --dry-run and --json behavior without human output or confirmation', async () => {
+      const result = await runNormal(['--json', ...bareArgs, '--dry-run']);
+
+      expect(result).to.deep.equal({ ...commandReportFixture(plan), dryRun: true });
+      expect(planStub.calledOnce).to.equal(true);
+      expect(confirm.called).to.equal(false);
+      expect(execute.called).to.equal(false);
+      expect(log.called).to.equal(false);
+      expect(logToStderr.called).to.equal(false);
+      expect(logJson.calledOnce).to.equal(true);
+    });
+
+    it('routes spaced command words and bare pairs through the actual CLI without deleting', async () => {
+      const result = await runCli(['flow', 'version', 'delete', ...bareArgs, '--dry-run', '--json'], {
+        root: fileURLToPath(new URL('../../../../', import.meta.url)),
+        devPlugins: false,
+        userPlugins: false,
+      });
+
+      expect(result).to.deep.equal({ ...commandReportFixture(plan), dryRun: true });
+      expect(
+        planStub.calledOnceWithExactly({ flowName: 'Invoice_Approval', versions: '2', namespace: undefined })
+      ).to.equal(true);
+      expect(confirm.called).to.equal(false);
+      expect(execute.called).to.equal(false);
+      expect(log.called).to.equal(false);
+      expect(logToStderr.called).to.equal(false);
+      expect(logJson.calledOnce).to.equal(true);
+    });
+
+    it('forwards bare namespace and API-version values alongside the required pairs', async () => {
+      await runNormal([...bareArgs, 'namespace', 'billing', 'api-version', '67.0', '--dry-run']);
+
+      expect(
+        planStub.calledOnceWithExactly({ flowName: 'Invoice_Approval', versions: '2', namespace: 'billing' })
+      ).to.equal(true);
+      expect(getConnection.calledOnceWithExactly('67.0')).to.equal(true);
+      expect(execute.called).to.equal(false);
+    });
+
+    it('requires --yes for a noninteractive mutation before planning or executing', async () => {
+      await expectError(bareArgs, 'requires --yes');
+
+      expect(planStub.called).to.equal(false);
+      expect(execute.called).to.equal(false);
+      expect(confirm.called).to.equal(false);
+      expect(getConnection.called).to.equal(false);
+    });
+
+    it('requires --yes for JSON mutation even with interactive stdin', async () => {
+      setInteractive(true);
+      await expectError([...bareArgs, '--json'], 'requires --yes');
+
+      expect(planStub.called).to.equal(false);
+      expect(execute.called).to.equal(false);
+      expect(confirm.called).to.equal(false);
+      expect(log.called).to.equal(false);
+      expect(logToStderr.called).to.equal(false);
+      expect(logJson.calledOnce).to.equal(true);
+    });
+
+    it('shows the exact plan, defaults interactive confirmation to no and cancels without execution', async () => {
+      setInteractive(true);
+      const result = await runNormal(bareArgs);
+
+      expect(planStub.firstCall.args).to.deep.equal([
+        { flowName: 'Invoice_Approval', versions: '2', namespace: undefined },
+      ]);
+      expect(result.outcome).to.equal('CANCELLED');
+      expect(result.confirmed).to.equal(false);
+      expect(result.deletion).to.equal(null);
+      expect(log.calledBefore(confirm)).to.equal(true);
+      expect(String(log.firstCall.args[0])).to.include('v2 | 301xx000003Ga19AAC | Draft');
+      expect(confirm.calledOnce).to.equal(true);
+      expect(confirm.firstCall.args[0]).to.include({ defaultAnswer: false });
+      expect((confirm.firstCall.args[0] as { message: string }).message).to.include('1 requested Flow versions');
+      expect(execute.called).to.equal(false);
+    });
+
+    it('allows one minute for bare-pair confirmation and cancels when the prompt times out unanswered', async () => {
+      setInteractive(true);
+      confirm.resolves(false);
+
+      const result = await runNormal(bareArgs);
+
+      expect(confirm.calledOnce).to.equal(true);
+      expect(confirm.firstCall.args[0]).to.include({ ms: 60_000, defaultAnswer: false });
+      expect(result.outcome).to.equal('CANCELLED');
+      expect(result.confirmed).to.equal(false);
+      expect(result.deletion).to.equal(null);
+      expect(execute.called).to.equal(false);
+      expect(String(log.lastCall.args[0])).to.include('Deletion cancelled');
+    });
+
+    it('executes the same displayed plan after explicit interactive confirmation', async () => {
+      setInteractive(true);
+      confirm.resolves(true);
+      const result = await runNormal(bareArgs);
+
+      expect(result.plan).to.equal(plan);
+      expect(log.calledBefore(confirm)).to.equal(true);
+      expect(confirm.calledBefore(execute)).to.equal(true);
+      expect(execute.calledOnceWithExactly(plan)).to.equal(true);
+      expect(result.confirmed).to.equal(true);
+      expect(result.deletion).to.equal(deletion);
+      expect(result.outcome).to.equal('SUCCEEDED');
+    });
+
+    it('uses native --yes and --json to execute exactly the resolved plan without prompting', async () => {
+      const result = await runNormal([...bareArgs, '--yes', '--json']);
+
+      expect(result).to.deep.equal({
+        ...commandReportFixture(plan),
+        confirmed: true,
+        outcome: 'SUCCEEDED',
+        deletion,
+      });
+      expect(planStub.calledOnce).to.equal(true);
+      expect(execute.calledOnceWithExactly(plan)).to.equal(true);
+      expect(confirm.called).to.equal(false);
+      expect(log.called).to.equal(false);
+      expect(logToStderr.called).to.equal(false);
+      expect(logJson.calledOnce).to.equal(true);
+    });
+
+    for (const commandArgs of [
+      ['--target-org', 'source', 'flow', 'Invoice_Approval', '--versions', '2'],
+      ['target-org', 'source', '-f', 'Invoice_Approval', 'versions', '2'],
+      ['versions', '2', '--flow=Invoice_Approval', 'target-org', 'source'],
+    ]) {
+      it(`accepts mixed standard flags and bare pairs: ${commandArgs.join(' ')}`, async () => {
+        const result = await runNormal([...commandArgs, '--yes']);
+
+        expect(
+          planStub.calledOnceWithExactly({ flowName: 'Invoice_Approval', versions: '2', namespace: undefined })
+        ).to.equal(true);
+        expect(createOrg.calledWithExactly({ aliasOrUsername: 'source' })).to.equal(true);
+        expect(execute.calledOnceWithExactly(plan)).to.equal(true);
+        expect(result.outcome).to.equal('SUCCEEDED');
+      });
+    }
+
+    for (const value of ['flow', 'versions', 'target-org']) {
+      it(`preserves ${value} as a value in bare pairs`, async () => {
+        await runNormal(['target-org', value, 'flow', value, 'versions', value, '--dry-run']);
+
+        expect(createOrg.calledWithExactly({ aliasOrUsername: value })).to.equal(true);
+        expect(planStub.calledOnceWithExactly({ flowName: value, versions: value, namespace: undefined })).to.equal(
+          true
+        );
+        expect(execute.called).to.equal(false);
+      });
+
+      it(`preserves ${value} as a standard flag value beside bare pairs`, async () => {
+        await runNormal(['--target-org', value, '--flow', value, 'versions', value, '--dry-run']);
+
+        expect(createOrg.calledWithExactly({ aliasOrUsername: value })).to.equal(true);
+        expect(planStub.calledOnceWithExactly({ flowName: value, versions: value, namespace: undefined })).to.equal(
+          true
+        );
+        expect(execute.called).to.equal(false);
+      });
+    }
+
+    for (const commandArgs of [
+      ['-o', 'source', '-f', 'Invoice_Approval', '--versions=2'],
+      ['--target-org=source', '--flow=Invoice_Approval', '--versions=2'],
+      ['-osource', '-fInvoice_Approval', '--versions', '2'],
+    ]) {
+      it(`preserves standard shorthand and equals flags: ${commandArgs.join(' ')}`, async () => {
+        const result = await runNormal([...commandArgs, '-y']);
+
+        expect(createOrg.calledWithExactly({ aliasOrUsername: 'source' })).to.equal(true);
+        expect(
+          planStub.calledOnceWithExactly({ flowName: 'Invoice_Approval', versions: '2', namespace: undefined })
+        ).to.equal(true);
+        expect(execute.calledOnceWithExactly(plan)).to.equal(true);
+        expect(confirm.called).to.equal(false);
+        expect(result.confirmed).to.equal(true);
+      });
+    }
+
+    it('preserves key-like values consumed by short flags and the standard versions flag', async () => {
+      await runNormal(['-o', 'flow', '-f', 'versions', '--versions', 'target-org', '--dry-run']);
+
+      expect(createOrg.calledWithExactly({ aliasOrUsername: 'flow' })).to.equal(true);
+      expect(
+        planStub.calledOnceWithExactly({ flowName: 'versions', versions: 'target-org', namespace: undefined })
+      ).to.equal(true);
+      expect(execute.called).to.equal(false);
+    });
+
+    const malformedCases = [
+      { name: 'a missing bare value', commandArgs: ['target-org', 'source', 'flow', 'Invoice_Approval', 'versions'] },
+      {
+        name: 'a standard flag in place of a bare value',
+        commandArgs: ['target-org', 'source', 'flow', '--versions', '2'],
+      },
+      {
+        name: 'a boolean flag in place of a bare value',
+        commandArgs: ['target-org', 'source', 'flow', 'Invoice_Approval', 'versions', '--dry-run'],
+      },
+      { name: 'an unknown bare pair', commandArgs: [...bareArgs, 'unexpected', 'value'] },
+      { name: 'unlabelled positional values', commandArgs: ['source', 'Invoice_Approval', '2'] },
+      {
+        name: 'a bare equals expression',
+        commandArgs: ['target-org', 'source', 'flow', 'Invoice_Approval', 'versions=2'],
+      },
+      { name: 'bare pairs after the end-of-options separator', commandArgs: ['--', ...bareArgs] },
+    ];
+
+    for (const { name, commandArgs } of malformedCases) {
+      it(`rejects ${name} without executing`, async () => {
+        await expectError(['--yes', ...commandArgs]);
+
+        expect(execute.called).to.equal(false);
+        expect(confirm.called).to.equal(false);
+      });
+    }
+
+    for (const token of ['yes', 'dry-run', 'json', 'help']) {
+      it(`does not treat bare ${token} as a boolean flag alias`, async () => {
+        await expectError([...bareArgs, '--yes', token]);
+
+        expect(planStub.called).to.equal(false);
+        expect(execute.called).to.equal(false);
+        expect(confirm.called).to.equal(false);
+      });
+    }
+
+    const duplicateCases = [
+      { name: 'bare Flow pairs', commandArgs: [...bareArgs, 'flow', 'Another_Flow'] },
+      { name: 'bare version pairs', commandArgs: [...bareArgs, 'versions', '3'] },
+      { name: 'bare target-org pairs', commandArgs: [...bareArgs, 'target-org', 'other'] },
+      { name: 'a bare Flow pair and --flow', commandArgs: [...bareArgs, '--flow', 'Another_Flow'] },
+      { name: '--flow and a bare Flow pair', commandArgs: [...args, 'flow', 'Another_Flow'] },
+      { name: 'a bare Flow pair and -f', commandArgs: [...bareArgs, '-f', 'Another_Flow'] },
+      { name: 'a bare Flow pair and --flow=', commandArgs: [...bareArgs, '--flow=Another_Flow'] },
+      { name: 'a bare version pair and --versions=', commandArgs: [...bareArgs, '--versions=3'] },
+      { name: 'a bare target-org pair and -o', commandArgs: [...bareArgs, '-o', 'other'] },
+      { name: 'standard --flow flags', commandArgs: [...args, '--flow', 'Another_Flow'] },
+      { name: '--flow and -f', commandArgs: [...args, '-f', 'Another_Flow'] },
+      { name: 'standard --versions flags', commandArgs: [...args, '--versions=3'] },
+      { name: 'standard --target-org flags', commandArgs: [...args, '--target-org=other'] },
+      { name: 'standard namespace flags', commandArgs: [...args, '--namespace', 'billing', '--namespace=other'] },
+      { name: 'standard API-version flags', commandArgs: [...args, '--api-version', '67.0', '--api-version=66.0'] },
+    ];
+
+    for (const { name, commandArgs } of duplicateCases) {
+      it(`rejects duplicate singleton options expressed as ${name} before planning or execution`, async () => {
+        await expectError([...commandArgs, '--yes']);
+
+        expect(planStub.called).to.equal(false);
+        expect(execute.called).to.equal(false);
+        expect(confirm.called).to.equal(false);
+      });
+    }
+  });
+
+  it('formats the selected versions with readable sections and one surrounding blank line', () => {
+    const output = formatVersionDeleteReport(commandReportFixture(plan));
+
+    expect(output).to.equal(
+      [
+        '',
+        '=== Flow version deletion',
+        'Target org: poc@example.com | API: 67.0 | Mode: NORMAL',
+        'Flow: Invoice_Approval',
+        'Definition: 300xx000000bojNAAQ',
+        '',
+        '=== Selected versions',
+        '  v2 | 301xx000003Ga19AAC | Draft | PASS',
+        '',
+        'Outcome: PREVIEWED',
+        'Warning: Client selection checks are not atomic.',
+        '',
+      ].join('\n')
+    );
+    expect(output.startsWith('\n\n')).to.equal(false);
+    expect(output.endsWith('\n\n')).to.equal(false);
+  });
+
+  it('sanitizes control characters in selected-version text without modifying the structured report', () => {
+    const report = commandReportFixture(plan);
+    report.targetOrg = 'poc\nspoof@example.com';
+    report.apiVersion = '67.0\r';
+    plan.flowName = 'Invoice\tApproval';
+    plan.namespace = 'billing\u001b';
+    plan.definitionId = '300\nspoof';
+    plan.versions[0].versionId = '301\nspoof';
+    plan.versions[0].status = 'Draft\u0007';
+    plan.warnings = ['Warning\nspoof'];
+    const output = formatVersionDeleteReport(report);
+
+    expect(output).to.include('Target org: poc spoof@example.com | API: 67.0  | Mode: NORMAL');
+    expect(output).to.include('Flow: billing __Invoice Approval');
+    expect(output).to.include('Definition: 300 spoof');
+    expect(output).to.include('v2 | 301 spoof | Draft ');
+    expect(output).to.include('Warning: Warning spoof');
+    for (const control of ['\r', '\t', '\u0007', '\u001b']) expect(output).not.to.include(control);
+    expect(report.targetOrg).to.equal('poc\nspoof@example.com');
+    expect(plan.versions[0].versionId).to.equal('301\nspoof');
+  });
+
+  it('renders per-version errors and execution warnings instead of preview warnings', () => {
+    const report = commandReportFixture(plan);
+    deletion.results[0].error = { code: 'DEPENDENCY\nBLOCK', message: 'Referenced\nby another component.' };
+    deletion.warnings = ['Not an atomic\nbatch.'];
+    report.deletion = deletion;
+    report.outcome = deletion.outcome;
+    report.confirmed = true;
+    const output = formatVersionDeleteReport(report);
+
+    expect(output).to.include('=== Results');
+    expect(output).to.include('DEPENDENCY BLOCK: Referenced by another component.');
+    expect(output).to.include('Warning: Not an atomic batch.');
+    expect(output).not.to.include('Client selection checks are not atomic.');
+    expect(output).not.to.include('=== Selected versions');
+  });
+
+  it('renders actual preview blocker messages and hides redacted evidence names', () => {
+    const report = commandReportFixture(plan);
+    blockTarget(plan.versions[0], 'PAUSED_INTERVIEWS', 'PAUSED_INTERVIEWS (1); FUTURE_BACKEND_REASON');
+    plan.versions[0].assessment!.evidence = [
+      {
+        sourceId: '0Fo000000000001CAA',
+        sourceType: 'FlowInterview',
+        sourceName: 'Hidden interview name',
+        targetKind: 'VERSION',
+        targetId: plan.versions[0].versionId!,
+        targetName: null,
+        channels: ['SETUP_RESTRICT'],
+        interviewRoles: ['PERSISTED_REFERENCE'],
+        detailsRedacted: true,
+      },
+    ];
+
+    const output = formatVersionDeleteReport(report);
+
+    expect(output).to.include('PAUSED_INTERVIEWS (1); FUTURE_BACKEND_REASON');
+    expect(output).to.include('Reference: FlowInterview | Details unavailable');
+    expect(output).not.to.include('Hidden interview name');
+    expect(plan.versions[0].assessment!.evidence[0].sourceName).to.equal('Hidden interview name');
+  });
+
+  it('identifies a client last-version safeguard separately from a backend blocker', () => {
+    const report = commandReportFixture(plan);
+    report.deletion = deletion;
+    report.outcome = 'FAILED';
+    Object.assign(deletion.results[0], {
+      state: 'BLOCKED',
+      source: 'CLIENT_POLICY',
+      targetDeleted: false,
+      error: { code: 'LAST_VERSION', message: 'The client preserves the last version pending product confirmation.' },
+    });
+
+    const output = formatVersionDeleteReport(report);
+
+    expect(output).to.include('Source: Client version-preservation safeguard (product policy pending)');
+    expect(output).to.include('LAST_VERSION');
+    expect(output).not.to.include('backend restriction');
+  });
+
+  it('removes ANSI and bidirectional controls from human output without changing JSON data', () => {
+    const report = commandReportFixture(plan);
+    report.targetOrg = '\u001b[31morg\u001b[0m\u202E@example.invalid';
+    blockTarget(plan.versions[0], 'FUTURE_REASON', 'Before\u001b]0;title\u0007after\u200Bcontrol');
+
+    const output = formatVersionDeleteReport(report);
+
+    expect(output).not.to.include('\u001b');
+    expect(output).not.to.include('\u202E');
+    expect(output).not.to.include('\u200B');
+    expect(output).to.include('org @example.invalid');
+    expect(output).to.include('Beforeafter control');
+    expect(report.targetOrg).to.include('\u001b');
+  });
+
+  it('validates preview, cancelled and execution contract-2 reports against the strict schema', () => {
+    const preview = commandReportFixture(plan);
+    const cancelled = { ...preview, outcome: 'CANCELLED' };
+    const executed = { ...preview, confirmed: true, outcome: 'SUCCEEDED', deletion };
+
+    for (const report of [preview, cancelled, executed]) {
+      expect(validateReport(report), JSON.stringify(validateReport.errors)).to.equal(true);
+    }
+  });
+
+  it('rejects obsolete JSON contract 1, legacy DELETED state and unexpected properties', () => {
+    const preview = commandReportFixture(plan);
+    const oldContract = { ...preview, contractVersion: '1' };
+    expect(validateReport(oldContract)).to.equal(false);
+    const oldResult = structuredClone({ ...preview, confirmed: true, outcome: 'SUCCEEDED', deletion });
+    oldResult.deletion.results[0].state = 'DELETED' as (typeof oldResult.deletion.results)[0]['state'];
+    expect(validateReport(oldResult)).to.equal(false);
+    expect(validateReport({ ...preview, fabricatedBlockers: [] })).to.equal(false);
+    const badOutcome = structuredClone({ ...preview, confirmed: true, outcome: 'SUCCEEDED', deletion });
+    badOutcome.deletion.results[0].targetDeleted = false;
+    expect(validateReport(badOutcome)).to.equal(false);
+  });
+});
diff --git a/test/commands/flow/version/deleteForce.test.ts b/test/commands/flow/version/deleteForce.test.ts
new file mode 100644
index 0000000..d255175
--- /dev/null
+++ b/test/commands/flow/version/deleteForce.test.ts
@@ -0,0 +1,427 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { readFileSync } from 'node:fs';
+import Ajv from 'ajv';
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { Org } from '@salesforce/core';
+import {
+  FlowVersionDeleteService,
+  FlowVersionForceDeleteService,
+  FlowVersionError,
+  type FlowVersionForceDeletePlan,
+  type FlowVersionForceDeleteResult,
+} from '@salesforce/flow-node';
+import { stubSfCommandUx } from '@salesforce/sf-plugins-core';
+import FlowVersionDelete from '../../../../src/commands/flow/version/delete.js';
+import {
+  formatVersionForceDeleteReport,
+  type FlowVersionForceDeleteCommandReport,
+} from '../../../../src/services/flowVersionForceDeletion.js';
+import { ForceDeleteConfirmationPrompt } from '../../../../src/ux/forceDeleteConfirmation.js';
+import { ConfirmationPrompt } from '../../../../src/ux/confirmation.js';
+
+const schema = JSON.parse(
+  readFileSync(new URL('../../../../schemas/flow-version-force-delete.json', import.meta.url), 'utf8')
+) as object;
+const validateReport = new Ajv({ allErrors: true }).compile(schema);
+
+const planFixture = (): FlowVersionForceDeletePlan => ({
+  contractVersion: '1',
+  orgId: '00D000000000001EAA',
+  definitionId: '300xx000000bojNAAQ',
+  versionId: '301xx000003Ga19AAC',
+  flowName: 'Invoice_Approval',
+  namespace: null,
+  versionNumber: 2,
+  availableVersionCount: 4,
+  impact: {
+    flowApiName: 'Invoice_Approval',
+    versionNumber: 2,
+    eligible: true,
+    reasonCode: null,
+    pausedInterviewCount: 3,
+    failedInterviewCount: 2,
+    otherInterviewCount: 1,
+    distinctUserCount: 4,
+    oldestInterviewAgeDays: 16,
+    orchestrationInProgressCount: 0,
+    referencingVersionCount: 0,
+    scheduledResumeWithin7Days: null,
+    workItemCount: null,
+  },
+  expiresAt: new Date(Date.now() + 600_000).toISOString(),
+  clientPolicyError: null,
+});
+
+const resultFixture = (plan: FlowVersionForceDeletePlan): FlowVersionForceDeleteResult => ({
+  contractVersion: '1',
+  mode: 'FORCE',
+  orgId: plan.orgId,
+  definitionId: plan.definitionId,
+  versionId: plan.versionId,
+  flowName: plan.flowName,
+  namespace: plan.namespace,
+  versionNumber: plan.versionNumber,
+  state: 'SUCCEEDED',
+  source: 'BACKEND',
+  targetDeleted: true,
+  abandonedInterviewCount: 6,
+  error: null,
+});
+
+const runForce = async (args: string[]): Promise<FlowVersionForceDeleteCommandReport> => {
+  const result = await FlowVersionDelete.run(args);
+  if (result.mode !== 'FORCE') throw new Error('A force command routed to normal deletion.');
+  return result;
+};
+
+describe('flow version delete --force command', () => {
+  const sandbox = sinon.createSandbox();
+  const args = ['--target-org', 'source', '--flow', 'Invoice_Approval', '--versions', '2', '--force'];
+  let plan: FlowVersionForceDeletePlan;
+  let result: FlowVersionForceDeleteResult;
+  let preview: sinon.SinonStub;
+  let execute: sinon.SinonStub;
+  let cancel: sinon.SinonStub;
+  let confirm: sinon.SinonStub;
+  let normalPlan: sinon.SinonStub;
+  let normalExecute: sinon.SinonStub;
+  let normalConfirm: sinon.SinonStub;
+  let getConnection: sinon.SinonStub;
+  let request: sinon.SinonStub;
+  let log: sinon.SinonStub;
+  let logJson: sinon.SinonStub;
+  let logToStderr: sinon.SinonStub;
+  let originalExitCode: typeof process.exitCode;
+  let ttyDescriptors: Array<PropertyDescriptor | undefined>;
+
+  const tty = (stdin = true, stdout = true, stderr = true): void => {
+    for (const [stream, interactive] of [
+      [process.stdin, stdin],
+      [process.stdout, stdout],
+      [process.stderr, stderr],
+    ] as const)
+      Object.defineProperty(stream, 'isTTY', { configurable: true, value: interactive });
+  };
+
+  const expectError = async (argv: string[], fragment: string): Promise<void> => {
+    let caught: unknown;
+    try {
+      await FlowVersionDelete.run(argv);
+    } catch (error) {
+      caught = error;
+    }
+    expect(caught).to.be.instanceOf(Error);
+    expect((caught as Error).message).to.include(fragment);
+  };
+
+  beforeEach(() => {
+    originalExitCode = process.exitCode;
+    process.exitCode = undefined;
+    ttyDescriptors = [process.stdin, process.stdout, process.stderr].map((stream) =>
+      Object.getOwnPropertyDescriptor(stream, 'isTTY')
+    );
+    tty();
+    plan = planFixture();
+    result = resultFixture(plan);
+    const ux = stubSfCommandUx(sandbox);
+    log = ux.log;
+    logJson = ux.logJson;
+    logToStderr = ux.logToStderr;
+    request = sandbox.stub();
+    getConnection = sandbox.stub().returns({
+      getApiVersion: () => '67.0',
+      getAuthInfoFields: () => ({ orgId: plan.orgId }),
+      tooling: { query: sandbox.stub(), queryMore: sandbox.stub() },
+      request,
+    });
+    sandbox.stub(Org, 'create').resolves({ getConnection, getUsername: () => 'poc@example.com' } as unknown as Org);
+    preview = sandbox.stub(FlowVersionForceDeleteService.prototype, 'preview').resolves(plan);
+    execute = sandbox.stub(FlowVersionForceDeleteService.prototype, 'execute').resolves(result);
+    cancel = sandbox.stub(FlowVersionForceDeleteService.prototype, 'cancel');
+    confirm = sandbox.stub(ForceDeleteConfirmationPrompt.prototype, 'confirm').resolves(false);
+    normalPlan = sandbox.stub(FlowVersionDeleteService.prototype, 'plan');
+    normalExecute = sandbox.stub(FlowVersionDeleteService.prototype, 'execute');
+    normalConfirm = sandbox.stub(ConfirmationPrompt.prototype, 'confirm');
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+    process.exitCode = originalExitCode;
+    for (const [index, stream] of [process.stdin, process.stdout, process.stderr].entries()) {
+      const descriptor = ttyDescriptors[index];
+      if (descriptor) Object.defineProperty(stream, 'isTTY', descriptor);
+      else Reflect.deleteProperty(stream, 'isTTY');
+    }
+  });
+
+  it('routes force preview only through the dedicated force service and burns its private capability', async () => {
+    const report = await runForce([...args, '--dry-run']);
+    expect(
+      preview.calledOnceWithExactly({ flowName: 'Invoice_Approval', versionNumber: 2, namespace: undefined })
+    ).to.equal(true);
+    expect(report).to.include({
+      mode: 'FORCE',
+      contractVersion: '1',
+      dryRun: true,
+      outcome: 'PREVIEWED',
+      confirmed: false,
+    });
+    expect(report.deletion).to.equal(null);
+    expect(
+      confirm.called ||
+        execute.called ||
+        normalPlan.called ||
+        normalExecute.called ||
+        normalConfirm.called ||
+        request.called
+    ).to.equal(false);
+    expect(cancel.calledOnceWithExactly(plan)).to.equal(true);
+    expect(validateReport(report), JSON.stringify(validateReport.errors)).to.equal(true);
+    expect(process.exitCode).to.equal(undefined);
+  });
+
+  for (const expression of ['1,2', '1-1', '1-3', '0', '01', '-2', '2.5', '9007199254740992']) {
+    it(`rejects a non-single version expression ${expression} before opening a connection`, async () => {
+      await expectError(
+        ['--target-org', 'source', '--flow', 'Invoice_Approval', '--versions', expression, '--force'],
+        'exactly one positive version'
+      );
+      expect(getConnection.called || preview.called || execute.called).to.equal(false);
+    });
+  }
+
+  it('requires interactive stdin even for force dry run and --yes', async () => {
+    tty(false, true, true);
+    await expectError([...args, '--dry-run', '--yes'], 'interactive input and output');
+    expect(getConnection.called || preview.called || execute.called || confirm.called).to.equal(false);
+  });
+
+  it('requires interactive stdout before any API call', async () => {
+    tty(true, false, true);
+    await expectError([...args, '--yes'], 'interactive input and output');
+    expect(getConnection.called || preview.called || execute.called).to.equal(false);
+  });
+
+  it('requires interactive stderr for JSON execution, while permitting a JSON-only preview', async () => {
+    tty(true, true, false);
+    await expectError([...args, '--yes', '--json'], 'interactive stderr');
+    expect(getConnection.called).to.equal(false);
+    logJson.resetHistory();
+    const report = await runForce([...args, '--dry-run', '--json']);
+    expect(report.outcome).to.equal('PREVIEWED');
+    expect(log.called || logToStderr.called || confirm.called || execute.called).to.equal(false);
+    expect(logJson.calledOnce).to.equal(true);
+  });
+
+  it('ignores --yes and still requests exact Flow/version confirmation after showing the full impact', async () => {
+    const report = await runForce([...args, '--yes']);
+    expect(confirm.calledOnce).to.equal(true);
+    expect(report.outcome).to.equal('CANCELLED');
+    expect(execute.called).to.equal(false);
+    expect(log.firstCall.args[0]).to.include('Paused interviews: 3').and.include('Failed interviews: 2');
+    expect(log.calledBefore(confirm)).to.equal(true);
+    expect(log.getCalls().some((call) => String(call.args[0]).includes('--yes is ignored'))).to.equal(true);
+    expect(confirm.firstCall.args[0]).to.include({
+      flowApiName: 'Invoice_Approval',
+      versionNumber: 2,
+      ms: 120_000,
+      output: process.stdout,
+    });
+    expect(cancel.calledOnceWithExactly(plan)).to.equal(true);
+    expect(validateReport(report), JSON.stringify(validateReport.errors)).to.equal(true);
+  });
+
+  it('uses backend-qualified Flow names for typed confirmation and forwards the explicit namespace', async () => {
+    plan.namespace = 'billing';
+    plan.impact.flowApiName = 'billing__Invoice_Approval';
+    await runForce([...args, '--namespace', 'billing']);
+    expect(preview.firstCall.args[0]).to.deep.equal({
+      flowName: 'Invoice_Approval',
+      versionNumber: 2,
+      namespace: 'billing',
+    });
+    expect(confirm.firstCall.args[0]).to.include({ flowApiName: 'billing__Invoice_Approval' });
+  });
+
+  it('preserves bare name/value arguments and explicit API version in force mode', async () => {
+    const report = await runForce([
+      'target-org',
+      'source',
+      'flow',
+      'Invoice_Approval',
+      'versions',
+      '2',
+      'api-version',
+      '67.0',
+      '--force',
+      '--dry-run',
+    ]);
+    expect(getConnection.calledOnceWithExactly('67.0')).to.equal(true);
+    expect(report.mode).to.equal('FORCE');
+    expect(preview.firstCall.args[0]).to.include({ versionNumber: 2 });
+  });
+
+  it('returns actual backend blockers without prompting or executing', async () => {
+    plan.impact.eligible = false;
+    plan.impact.reasonCode = 'ACTIVE_ORCHESTRATION';
+    plan.impact.orchestrationInProgressCount = 2;
+    plan.expiresAt = null;
+    const report = await runForce(args);
+    expect(report.outcome).to.equal('BLOCKED');
+    expect(process.exitCode).to.equal(1);
+    expect(confirm.called || execute.called).to.equal(false);
+    expect(log.firstCall.args[0]).to.include('ACTIVE_ORCHESTRATION').and.include('Orchestrations in progress: 2');
+    expect(validateReport(report), JSON.stringify(validateReport.errors)).to.equal(true);
+  });
+
+  it('keeps blocked preview exit zero and preserves null metadata instead of inventing counts', async () => {
+    Object.assign(plan.impact, {
+      eligible: false,
+      reasonCode: 'NOT_FOUND',
+      flowApiName: null,
+      versionNumber: null,
+      pausedInterviewCount: null,
+      distinctUserCount: null,
+    });
+    plan.expiresAt = null;
+    const report = await runForce([...args, '--dry-run', '--json']);
+    expect(report.outcome).to.equal('PREVIEWED');
+    expect(report.plan.impact.pausedInterviewCount).to.equal(null);
+    expect(process.exitCode).to.equal(undefined);
+    expect(confirm.called || execute.called).to.equal(false);
+    expect(validateReport(report), JSON.stringify(validateReport.errors)).to.equal(true);
+  });
+
+  it('keeps the last-version client policy distinct from backend eligibility', async () => {
+    plan.clientPolicyError = { code: 'LAST_VERSION_PENDING_POLICY', message: 'Preserve the last remaining version.' };
+    const report = await runForce(args);
+    expect(report.plan.impact.eligible).to.equal(true);
+    expect(report.outcome).to.equal('BLOCKED');
+    expect(process.exitCode).to.equal(1);
+    expect(confirm.called || execute.called).to.equal(false);
+    expect(log.firstCall.args[0]).to.include('Client policy: LAST_VERSION_PENDING_POLICY');
+  });
+
+  it('refuses an expiring preview rather than shortening typing time or automatically refreshing', async () => {
+    plan.expiresAt = new Date(Date.now() + 59_000).toISOString();
+    await expectError(args, 'less than one minute remaining');
+    expect(preview.calledOnce).to.equal(true);
+    expect(confirm.called || execute.called).to.equal(false);
+    expect(cancel.calledOnce).to.equal(true);
+  });
+
+  it('bounds typing by the remaining token lifetime without reducing it below one minute', async () => {
+    const clock = sandbox.useFakeTimers({ now: Date.now() });
+    plan.expiresAt = new Date(clock.now + 90_000).toISOString();
+    await runForce(args);
+    expect(confirm.firstCall.args[0]).to.include({ ms: 90_000 });
+  });
+
+  it('executes exactly once only after typed approval and returns the real abandoned count', async () => {
+    confirm.resolves(true);
+    const report = await runForce(args);
+    expect(execute.calledOnceWithExactly(plan)).to.equal(true);
+    expect(report).to.include({ confirmed: true, confirmationMethod: 'TYPED_FLOW_AND_VERSION', outcome: 'SUCCEEDED' });
+    expect(report.deletion?.abandonedInterviewCount).to.equal(6);
+    expect(cancel.calledOnceWithExactly(plan)).to.equal(true);
+    expect(normalPlan.called || normalExecute.called || normalConfirm.called || request.called).to.equal(false);
+    expect(validateReport(report), JSON.stringify(validateReport.errors)).to.equal(true);
+  });
+
+  it('sends the human impact and typed prompt to stderr while JSON stdout remains clean', async () => {
+    confirm.resolves(true);
+    const report = await runForce([...args, '--json', '--yes']);
+    expect(log.called).to.equal(false);
+    expect(logToStderr.firstCall.args[0]).to.include('=== Impact preview');
+    expect(logToStderr.calledBefore(confirm)).to.equal(true);
+    expect(confirm.firstCall.args[0]).to.include({ output: process.stderr });
+    expect(logJson.calledOnce).to.equal(true);
+    expect(report.outcome).to.equal('SUCCEEDED');
+    expect(JSON.stringify(report)).not.to.include('confirmationToken').and.not.to.include('expiresInSeconds');
+  });
+
+  for (const state of ['BLOCKED', 'FAILED', 'UNKNOWN'] as const) {
+    it(`preserves SDK ${state} without retry and maps its execution exit code`, async () => {
+      Object.assign(result, {
+        state,
+        targetDeleted: state === 'UNKNOWN' ? null : false,
+        abandonedInterviewCount: null,
+        error: { code: 'SERVER_RESULT', message: 'Use a fresh preview or reconcile the exact target.' },
+      });
+      confirm.resolves(true);
+      const report = await runForce([...args, '--json']);
+      expect(report.outcome).to.equal(state);
+      expect(process.exitCode).to.equal(state === 'BLOCKED' ? 1 : 2);
+      expect(preview.calledOnce && execute.calledOnce && confirm.calledOnce).to.equal(true);
+      expect(validateReport(report), JSON.stringify(validateReport.errors)).to.equal(true);
+    });
+  }
+
+  it('refuses to execute if a terminal is lost during typed confirmation', async () => {
+    confirm.callsFake(async () => {
+      tty(true, false, true);
+      return true;
+    });
+    await expectError(args, 'interactive input and output');
+    expect(execute.called).to.equal(false);
+    expect(cancel.calledOnce).to.equal(true);
+  });
+
+  it('burns private preview state when the prompt fails and does not retry it', async () => {
+    confirm.rejects(new Error('Prompt transport failed.'));
+    await expectError(args, 'Prompt transport failed');
+    expect(execute.called).to.equal(false);
+    expect(cancel.calledOnce).to.equal(true);
+  });
+
+  it('maps SDK preview failures to typed CLI errors without executing', async () => {
+    preview.rejects(new FlowVersionError('FORCE_PREVIEW_FAILED', 'Unable to obtain a force preview.'));
+    await expectError([...args, '--dry-run'], 'Unable to obtain a force preview');
+    expect(confirm.called || execute.called || cancel.called).to.equal(false);
+  });
+
+  it('renders real metrics, unknown scheduling/work items and irreversible effects without invented referencing versions', async () => {
+    const report = await runForce([...args, '--dry-run']);
+    const rendered = formatVersionForceDeleteReport(report);
+    expect(rendered)
+      .to.include('Other saved interviews: 1')
+      .and.include('Distinct users: 4')
+      .and.include('Oldest interview age: 16d');
+    expect(rendered)
+      .to.include('Referencing Flow versions: 0')
+      .and.include('Unavailable (not stored on the interview)')
+      .and.include('Unavailable (not keyed by Flow version)');
+    expect(rendered).to.include('cannot be resumed or retried').and.include('cannot be undone');
+    expect(rendered).not.to.include('Setup Audit Trail').and.not.to.include('Referencing versions: Parent');
+  });
+
+  it('sanitizes terminal controls in display without altering structured server values', async () => {
+    plan.impact.flowApiName = 'Invoice_Approval\u001b[31m\n';
+    const report = await runForce([...args, '--dry-run']);
+    const rendered = formatVersionForceDeleteReport(report);
+    expect(rendered).not.to.include('\u001b');
+    expect(report.plan.impact.flowApiName).to.equal('Invoice_Approval\u001b[31m\n');
+  });
+
+  it('rejects unexpected report properties and a fake success through its documented JSON schema', async () => {
+    const report = await runForce([...args, '--dry-run']);
+    expect(validateReport({ ...report, confirmationToken: 'never-public' })).to.equal(false);
+    expect(validateReport({ ...report, outcome: 'SUCCEEDED' })).to.equal(false);
+  });
+});
diff --git a/test/commands/flow/version/list.test.ts b/test/commands/flow/version/list.test.ts
new file mode 100644
index 0000000..601d3cb
--- /dev/null
+++ b/test/commands/flow/version/list.test.ts
@@ -0,0 +1,644 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { fileURLToPath } from 'node:url';
+import { readFileSync } from 'node:fs';
+import { stripVTControlCharacters } from 'node:util';
+import Ajv from 'ajv';
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { run as runCli } from '@oclif/core';
+import { Org, SfError } from '@salesforce/core';
+import {
+  ConnectFlowVersionListClient,
+  FlowVersionError,
+  FlowVersionService,
+  type ConnectFlowVersionListReport,
+} from '@salesforce/flow-node';
+import { stubSfCommandUx } from '@salesforce/sf-plugins-core';
+import FlowVersionList, {
+  formatVersionListReport,
+  type FlowVersionListCommandReport,
+} from '../../../../src/commands/flow/version/list.js';
+import { ConfirmationPrompt } from '../../../../src/ux/confirmation.js';
+import { formatFlowVersionTable, type FlowVersionTableRow } from '../../../../src/ux/flowVersionTable.js';
+
+const reportFixture = (): ConnectFlowVersionListReport => ({
+  contractVersion: '1',
+  orgId: '00D000000000001EAA',
+  generatedAt: '2026-10-27T12:00:00.000Z',
+  scope: { all: false, flowName: 'Invoice_Approval', namespace: null, allNamespaces: false },
+  filters: { status: null, olderThan: null, minPercent: null, deletable: false },
+  versionLimit: 25,
+  returnedVersionCount: 1,
+  candidateVersionCount: 3,
+  listTruncated: false,
+  catalogComplete: false,
+  nextOffset: null,
+  flows: [
+    {
+      definitionId: '300xx000000bojNAAQ',
+      apiName: 'Invoice_Approval',
+      label: 'Invoice Approval',
+      versionCount: 3,
+      limitPercent: 12,
+      versions: [
+        {
+          versionId: '301xx000003Ga19AAC',
+          versionNumber: 2,
+          versionName: 'Invoice Approval - Review',
+          status: 'Draft',
+          createdDate: '2026-10-01T12:00:00.000Z',
+          ageDays: 26,
+          createdById: '005000000000001AAA',
+          createdByName: 'Flow Author',
+          lastModifiedDate: '2026-10-02T12:00:00.000Z',
+          referenceCount: 0,
+          pausedInterviewCount: 0,
+          failedInterviewCount: 0,
+          deletable: true,
+          outcome: 'PASS',
+          reasonCode: null,
+          message: null,
+        },
+      ],
+    },
+  ],
+});
+const commandReportFixture = (report = reportFixture()): FlowVersionListCommandReport => ({
+  ...report,
+  targetOrg: 'poc@example.com',
+  apiVersion: '67.0',
+});
+const blocked = (
+  report: ConnectFlowVersionListReport,
+  message = 'PAUSED_INTERVIEWS (2); REFERENCED_BY_VERSION (ParentFlow)'
+): void => {
+  Object.assign(report.flows[0].versions[0], {
+    outcome: 'BLOCKED',
+    deletable: false,
+    reasonCode: 'PAUSED_INTERVIEWS',
+    message,
+    referenceCount: 2,
+    pausedInterviewCount: 2,
+    failedInterviewCount: 1,
+  });
+};
+const errored = (report: ConnectFlowVersionListReport): void => {
+  Object.assign(report.flows[0].versions[0], {
+    outcome: 'ERROR',
+    deletable: false,
+    reasonCode: 'OWNED_RESOURCE_CHECK_INCOMPLETE',
+    message: null,
+    referenceCount: null,
+    pausedInterviewCount: null,
+    failedInterviewCount: null,
+  });
+};
+const wirePage = (report = reportFixture()): object => ({
+  contractVersion: report.contractVersion,
+  versionLimit: report.versionLimit,
+  returnedVersionCount: report.returnedVersionCount,
+  candidateVersionCount: report.returnedVersionCount,
+  listTruncated: report.listTruncated,
+  nextOffset: report.nextOffset,
+  flows: report.flows.map((flow) => ({
+    ...structuredClone(flow),
+    versionCount: flow.versions.length,
+    limitPercent: Math.floor((flow.versions.length * 100) / report.versionLimit),
+  })),
+});
+
+describe('flow version list command', () => {
+  const sandbox = sinon.createSandbox();
+  const args = ['--target-org', 'source', '--flow', 'Invoice_Approval'];
+  let report: ConnectFlowVersionListReport;
+  let list: sinon.SinonStub;
+  let getConnection: sinon.SinonStub;
+  let log: sinon.SinonStub;
+  let logJson: sinon.SinonStub;
+  let logToStderr: sinon.SinonStub;
+  let execute: sinon.SinonStub;
+  let confirm: sinon.SinonStub;
+  let request: sinon.SinonStub;
+  let native: boolean;
+  let originalExitCode: typeof process.exitCode;
+  const expectError = async (commandArgs: string[], fragment?: string): Promise<Error> => {
+    let caught: unknown;
+    try {
+      await FlowVersionList.run(commandArgs);
+    } catch (error) {
+      caught = error;
+    }
+    expect(caught).to.be.instanceOf(Error);
+    if (fragment) expect((caught as Error).message).to.include(fragment);
+    return caught as Error;
+  };
+  beforeEach(() => {
+    originalExitCode = process.exitCode;
+    process.exitCode = undefined;
+    native = false;
+    report = reportFixture();
+    const ux = stubSfCommandUx(sandbox);
+    log = ux.log;
+    logJson = ux.logJson;
+    logToStderr = ux.logToStderr;
+    request = sandbox.stub();
+    getConnection = sandbox
+      .stub()
+      .returns({ getApiVersion: () => '67.0', getAuthInfoFields: () => ({ orgId: '00D000000000001EAA' }), request });
+    sandbox.stub(Org, 'create').resolves({ getConnection, getUsername: () => 'poc@example.com' } as unknown as Org);
+    list = sandbox.stub(ConnectFlowVersionListClient.prototype, 'list').resolves(report);
+    execute = sandbox.stub(FlowVersionService.prototype, 'execute');
+    confirm = sandbox.stub(ConfirmationPrompt.prototype, 'confirm');
+  });
+  afterEach(() => {
+    expect(execute.called).to.equal(false);
+    expect(confirm.called).to.equal(false);
+    if (!native) expect(request.called).to.equal(false);
+    process.exitCode = originalExitCode;
+    sandbox.restore();
+  });
+
+  it('lists an arbitrary Flow using only the authenticated Connect list client', async () => {
+    const result = await FlowVersionList.run(args);
+    expect(list.calledOnceWithExactly({ flowName: 'Invoice_Approval', all: false, deletable: false })).to.equal(true);
+    expect(result).to.deep.equal(commandReportFixture(report));
+    expect(getConnection.calledOnceWithExactly(undefined)).to.equal(true);
+    expect(log.calledOnce).to.equal(true);
+    expect(String(log.firstCall.args[0])).to.include('Deletable');
+  });
+  it('forwards API version, native status, age and usage filters', async () => {
+    await FlowVersionList.run([
+      '-o',
+      'source',
+      '-f',
+      'billing__Receipt_Reconciliation',
+      '--api-version',
+      '67.0',
+      '--status',
+      'Draft',
+      '--older-than',
+      '90d',
+      '--min-percent',
+      '80',
+    ]);
+    expect(
+      list.calledOnceWithExactly({
+        flowName: 'billing__Receipt_Reconciliation',
+        all: false,
+        deletable: false,
+        status: 'Draft',
+        olderThan: '90d',
+        minPercent: 80,
+      })
+    ).to.equal(true);
+    expect(getConnection.calledOnceWithExactly('67.0')).to.equal(true);
+  });
+  it('forwards --deletable to the server-backed SDK without local eligibility rules', async () => {
+    await FlowVersionList.run([...args, '--deletable']);
+    expect(list.firstCall.args[0]).to.deep.equal({ flowName: 'Invoice_Approval', all: false, deletable: true });
+  });
+  it('supports an all-org scope without injecting namespace restrictions', async () => {
+    await FlowVersionList.run(['-o', 'source', '--all']);
+    expect(list.firstCall.args[0]).to.deep.equal({ all: true, deletable: false });
+  });
+  it('returns native grouped contract 1 and authoritative counts without duplicate legacy arrays', async () => {
+    const result = await FlowVersionList.run([...args, '--json']);
+    expect(result).to.deep.equal(commandReportFixture(report));
+    expect(result.contractVersion).to.equal('1');
+    expect(result.flows[0].versions[0].referenceCount).to.equal(0);
+    for (const field of ['rows', 'assessmentErrors', 'countErrors', 'capacityErrors'])
+      expect(result).not.to.have.property(field);
+    expect(log.called).to.equal(false);
+    expect(logToStderr.called).to.equal(false);
+    expect(logJson.firstCall.args[0]).to.deep.include({ status: 0, result });
+  });
+  it('retains mixed PASS and ERROR rows in JSON and exits 1 after returning the report', async () => {
+    const success = structuredClone(report.flows[0].versions[0]);
+    errored(report);
+    report.flows[0].versions.push({ ...success, versionNumber: 3, versionId: '301000000000003AAA' });
+    report.returnedVersionCount = 2;
+    const result = await FlowVersionList.run([...args, '--json']);
+    expect(result.flows[0].versions).to.have.length(2);
+    expect(process.exitCode).to.equal(1);
+    expect(logJson.firstCall.args[0]).to.deep.include({ status: 1, result });
+  });
+  it('does not treat BLOCKED alone as an operational failure', async () => {
+    blocked(report);
+    await FlowVersionList.run([...args, '--json']);
+    expect(process.exitCode).to.equal(undefined);
+    expect(logJson.firstCall.args[0]).to.include({ status: 0 });
+  });
+  it('marks a server-truncated result incomplete in console and JSON exit status', async () => {
+    report.listTruncated = true;
+    const result = await FlowVersionList.run(args);
+    expect(result.listTruncated).to.equal(true);
+    expect(process.exitCode).to.equal(1);
+    expect(String(log.firstCall.args[0])).to.include('not a complete inventory');
+  });
+  it('keeps an actual zero limit and null percentage without inventing capacity errors', async () => {
+    report.versionLimit = 0;
+    report.flows[0].limitPercent = null;
+    const result = await FlowVersionList.run([...args, '--json']);
+    expect(result.versionLimit).to.equal(0);
+    expect(result.flows[0].limitPercent).to.equal(null);
+    expect(process.exitCode).to.equal(undefined);
+  });
+  it('maps typed SDK validation and protocol failures to SfError', async () => {
+    list.rejects(new FlowVersionError('INVALID_LIST_RESPONSE', 'List response rejected.'));
+    const error = await expectError(args, 'List response rejected.');
+    expect(error).to.be.instanceOf(SfError);
+    expect((error as SfError).code).to.equal('INVALID_LIST_RESPONSE');
+    expect(log.called).to.equal(false);
+  });
+  it('preserves a normal SDK whole-request failure', async () => {
+    list.rejects(new SfError('List request failed.', 'LIST_REQUEST_FAILED'));
+    expect((await expectError(args, 'List request failed.')).name).to.equal('LIST_REQUEST_FAILED');
+  });
+  it('routes normal spaced command words and standard flags through the real CLI', async () => {
+    const result = await runCli(['flow', 'version', 'list', ...args, '--json'], {
+      root: fileURLToPath(new URL('../../../../', import.meta.url)),
+      devPlugins: false,
+      userPlugins: false,
+    });
+    expect(result).to.deep.equal(commandReportFixture(report));
+    expect(list.calledOnce).to.equal(true);
+  });
+  it('requires exactly one scope before opening a connection', async () => {
+    await expectError(['-o', 'source'], 'Choose exactly one scope');
+    expect(list.called).to.equal(false);
+    expect(getConnection.called).to.equal(false);
+  });
+  it('rejects simultaneous --flow and --all', async () => {
+    await expectError([...args, '--all']);
+    expect(list.called).to.equal(false);
+    expect(getConnection.called).to.equal(false);
+  });
+  for (const value of ['-1', '101', '80.5', 'many']) {
+    it(`rejects invalid --min-percent ${value}`, async () => {
+      await expectError([...args, '--min-percent', value]);
+      expect(list.called).to.equal(false);
+      expect(getConnection.called).to.equal(false);
+    });
+  }
+  for (const value of ['0', '100']) {
+    it(`accepts the --min-percent boundary ${value}`, async () => {
+      await FlowVersionList.run([...args, '--min-percent', value]);
+      expect(list.firstCall.args[0]).to.include({ minPercent: Number(value) });
+    });
+  }
+  it('rejects mutation flags', async () => {
+    await expectError([...args, '--force'], '--force');
+    expect(list.called).to.equal(false);
+  });
+  it('provides help without authenticating', async () => {
+    await runCli(['flow', 'version', 'list', '--help'], {
+      root: fileURLToPath(new URL('../../../../', import.meta.url)),
+      devPlugins: false,
+      userPlugins: false,
+    });
+    expect(list.called).to.equal(false);
+    expect(getConnection.called).to.equal(false);
+  });
+  it('calls only the Core list endpoint through the native connection interface', async () => {
+    list.restore();
+    native = true;
+    request.resolves(wirePage());
+    const result = await FlowVersionList.run([...args, '--api-version', '67.0', '--json']);
+    expect(result.flows[0].versions[0].referenceCount).to.equal(0);
+    expect(request.calledOnce).to.equal(true);
+    const [req, opts] = request.firstCall.args as [{ method: string; url: string; body: string }, unknown];
+    const body = JSON.parse(req.body) as Record<string, unknown>;
+    expect(req.method).to.equal('POST');
+    expect(req.url).to.equal('/connect/interaction/flow-versions/list');
+    expect(body).to.include({
+      contractVersion: '1',
+      flowApiName: 'Invoice_Approval',
+      offset: 0,
+      limit: 100,
+    });
+    expect(body).not.to.have.property('deletable');
+    expect(opts).to.deep.include({ followRedirect: false, retry: { methods: [], maxRetries: 0 } });
+  });
+  it('continues an empty page using the server nextOffset instead of row count', async () => {
+    list.restore();
+    native = true;
+    const filtered = reportFixture();
+    filtered.candidateVersionCount = 600;
+    filtered.versionLimit = 1000;
+    filtered.flows[0].versionCount = 600;
+    filtered.flows[0].limitPercent = 60;
+    const page = {
+      ...wirePage(filtered),
+      candidateVersionCount: 600,
+      flows: structuredClone(filtered.flows),
+    };
+    request.onFirstCall().resolves({ ...page, returnedVersionCount: 0, flows: [], nextOffset: 500 });
+    request.onSecondCall().resolves(page);
+    const result = await FlowVersionList.run([...args, '--deletable', '--json']);
+    expect(request.callCount).to.equal(2);
+    const body = JSON.parse((request.secondCall.args[0] as { body: string }).body) as Record<string, unknown>;
+    expect(body.offset).to.equal(500);
+    expect(body.deletable).to.equal(true);
+    expect(result.returnedVersionCount).to.equal(1);
+    expect(result.candidateVersionCount).to.equal(600);
+  });
+  it('rejects unsupported namespace filtering before any API request', async () => {
+    list.restore();
+    native = true;
+    await expectError([...args, '--namespace', 'billing'], 'namespace');
+    expect(request.called).to.equal(false);
+  });
+});
+
+const plainText = (value: string): string => stripVTControlCharacters(value);
+const tableText = (value: string): string =>
+  plainText(value)
+    .replace(/[│┃┏┓┗┛┌┐└┘┬┴┼─━├┤╭╮╯╰]/gu, ' ')
+    .replace(/\s+/gu, ' ')
+    .trim();
+const textWithoutLayout = (value: string): string => tableText(value).replace(/\s/gu, '');
+
+describe('formatVersionListReport', () => {
+  it('displays every required A3/C1 field and actual Core capacity/count values', () => {
+    const report = commandReportFixture();
+    const output = formatVersionListReport(report, 120);
+    const text = tableText(output);
+    expect(output.startsWith('\n=== Flow versions\n')).to.equal(true);
+    expect(output.endsWith('\n')).to.equal(true);
+    expect(text).to.include('Version usage: 3/25 (12%) before filtering');
+    for (const field of [
+      'Flow Version Name Invoice Approval - Review',
+      'Version 2',
+      'Status Draft',
+      'Age 26d',
+      'Created By Flow Author',
+      'Created Date 2026-10-01T12:00:00.000Z',
+      'Last Modified Date 2026-10-02T12:00:00.000Z',
+      'Referenced By 0',
+      'Paused Interviews 0',
+      'Failed Interviews 0',
+      'Deletable Yes',
+      'Reason —',
+    ])
+      expect(text, field).to.include(field);
+    for (const internal of [
+      report.flows[0].definitionId,
+      report.flows[0].versions[0].versionId,
+      'Warning:',
+      'assessmentErrors',
+    ])
+      expect(text).not.to.include(internal);
+  });
+  it('shows No and the complete opaque backend explanation without extra evidence lookup', () => {
+    const report = commandReportFixture();
+    const message = 'PAUSED_INTERVIEWS (2); REFERENCED_BY_VERSION (ParentFlow, OtherFlow)';
+    blocked(report, message);
+    const output = formatVersionListReport(report, 100);
+    expect(tableText(output)).to.include('Deletable No');
+    expect(textWithoutLayout(output)).to.include(message.replace(/\s/gu, ''));
+    for (const value of ['Referenced By 2', 'Paused Interviews 2', 'Failed Interviews 1'])
+      expect(tableText(output)).to.include(value);
+    expect(output).not.to.include('Blocker details');
+  });
+  it('preserves unknown future reason messages', () => {
+    const report = commandReportFixture();
+    blocked(report, 'NEW_SERVER_POLICY: custom detail');
+    report.flows[0].versions[0].reasonCode = 'NEW_SERVER_POLICY';
+    expect(tableText(formatVersionListReport(report, 120))).to.include('Reason NEW_SERVER_POLICY: custom detail');
+  });
+  it('renders only the server verdict without local status/count blocker rules', () => {
+    const report = commandReportFixture();
+    Object.assign(report.flows[0].versions[0], {
+      status: 'Active',
+      referenceCount: 4,
+      pausedInterviewCount: 9,
+      failedInterviewCount: 3,
+    });
+    const text = tableText(formatVersionListReport(report, 120));
+    expect(text).to.include('Deletable Yes');
+    expect(text).to.include('Paused Interviews 9');
+  });
+  it('shows Error separately from No and leaves real null counts unavailable', () => {
+    const report = commandReportFixture();
+    errored(report);
+    const text = tableText(formatVersionListReport(report, 120));
+    expect(text).to.include('Deletable Error');
+    expect(text).to.include('Reason OWNED_RESOURCE_CHECK_INCOMPLETE');
+    for (const field of ['Referenced By', 'Paused Interviews', 'Failed Interviews'])
+      expect(text).to.include(field + ' Unavailable');
+    expect(text).not.to.include('Deletable No');
+    expect(text).not.to.include('Referenced By 0');
+  });
+  it('preserves the server integer utilization percentage rather than recalculating it', () => {
+    const report = commandReportFixture();
+    report.versionLimit = 30;
+    report.flows[0].limitPercent = 10;
+    expect(formatVersionListReport(report, 120)).to.include('Version usage: 3/30 (10%)');
+  });
+  it('displays null metadata as unavailable without synthesizing names, dates or ages', () => {
+    const report = commandReportFixture();
+    const v = report.flows[0].versions[0];
+    Object.assign(v, {
+      versionName: null,
+      createdByName: null,
+      createdDate: null,
+      lastModifiedDate: null,
+      ageDays: null,
+      status: null,
+    });
+    report.flows[0].versionCount = null;
+    report.flows[0].limitPercent = null;
+    const text = tableText(formatVersionListReport(report, 120));
+    for (const field of [
+      'Status Unavailable',
+      'Age Unavailable',
+      'Created Date Unavailable',
+      'Last Modified Date Unavailable',
+      'Created By Name unavailable',
+      'Flow Version Name Name unavailable',
+    ])
+      expect(text).to.include(field);
+    expect(text).to.include('count unavailable/25 (percentage unavailable)');
+  });
+  it('keeps zero limit and undefined percentage explicit', () => {
+    const report = commandReportFixture();
+    report.versionLimit = 0;
+    report.flows[0].limitPercent = null;
+    const text = formatVersionListReport(report, 120);
+    expect(text).to.include('3/0 (percentage unavailable)');
+    expect(text).not.to.include('Infinity');
+    expect(text).not.to.include('VERSION_LIMIT_UNAVAILABLE');
+  });
+  it('reports a genuinely empty selection and separately identifies server truncation', () => {
+    const report = commandReportFixture();
+    report.flows = [];
+    report.returnedVersionCount = 0;
+    expect(formatVersionListReport(report)).to.include('No Flow versions match');
+    report.listTruncated = true;
+    const output = formatVersionListReport(report);
+    expect(output).to.include('incomplete list');
+    expect(output).not.to.include('No Flow versions match');
+  });
+  it('sanitizes backend and org control characters while preserving JSON values separately', () => {
+    const report = commandReportFixture();
+    blocked(report, '\u001b]8;;https://example.com\u0007link\nforged\u202e');
+    report.targetOrg = '\u001b[31munsafe\u001b[0m\norg\u202e';
+    report.flows[0].apiName = 'Invoice\nFORGED';
+    Object.assign(report.flows[0].versions[0], {
+      versionName: 'Review\nFORGED\u202e',
+      createdByName: 'Author\nFORGED\u001b[31m',
+    });
+    const output = plainText(formatVersionListReport(report, 120));
+    for (const control of ['\u0007', '\u202e', '\r', '\t']) expect(output).not.to.include(control);
+    expect(output).to.include('Target org: unsafe org');
+    expect(output).not.to.include('\nFORGED');
+    expect(report.flows[0].versions[0].versionName).to.include('\nFORGED');
+  });
+});
+
+describe('standard Flow version table', () => {
+  const row = (): FlowVersionTableRow => ({
+    versionName: 'Invoice Approval - Review',
+    version: '2',
+    status: 'Draft',
+    age: '26d',
+    creator: 'Flow Author',
+    createdDate: '2026-10-01T12:00:00.000Z',
+    lastModifiedDate: '2026-10-02T12:00:00.000Z',
+    references: '2',
+    paused: '1',
+    failed: '1',
+    deletable: 'No',
+    reason: 'PAUSED_INTERVIEWS (1); FUTURE_SERVER_POLICY (a complete explanation that must never be truncated)',
+  });
+
+  it('uses all A3/C1 columns in wide consoles and keeps every complete value', () => {
+    const value = row();
+    const text = formatFlowVersionTable([value], 360);
+    const dataLines = plainText(text)
+      .split('\n')
+      .filter((line) => line.startsWith('│'))
+      .slice(1)
+      .map((line) => line.split('│').slice(1, -1));
+    for (const [index, field] of Object.values(value).entries()) {
+      const cell = dataLines
+        .map((line) => line[index] ?? '')
+        .join('')
+        .replace(/\s/gu, '');
+      expect(cell, field).to.equal(field.replace(/\s/gu, ''));
+    }
+    expect(text).to.include('Last Modified Date');
+    expect(text).not.to.include('Field');
+  });
+
+  it('uses a readable Field/Value table in normal consoles and wraps rather than truncating reasons', () => {
+    const value = row();
+    const text = formatFlowVersionTable([value], 80);
+    expect(text).to.include('Field');
+    expect(text).to.include('Value');
+    for (const field of Object.values(value))
+      expect(textWithoutLayout(text), field).to.include(field.replace(/\s/gu, ''));
+    for (const line of plainText(text).split('\n')) expect(Array.from(line).length).to.be.at.most(80);
+  });
+
+  it('returns no table for an empty list', () => {
+    expect(formatFlowVersionTable([], 80)).to.equal('');
+  });
+});
+
+describe('Flow version list JSON contract', () => {
+  const schema = JSON.parse(
+    readFileSync(new URL('../../../../schemas/flow-version-list.json', import.meta.url), 'utf8')
+  ) as object;
+  const validate = new Ajv({ allErrors: true }).compile(schema);
+  it('validates native grouped rows with authoritative counts and configured limit', () => {
+    const report = commandReportFixture();
+    expect(validate(report), JSON.stringify(validate.errors)).to.equal(true);
+    expect(report.contractVersion).to.equal('1');
+    expect(report.flows[0].versions[0]).not.to.have.property('assessment');
+  });
+  it('validates BLOCKED and ERROR without duplicated error collections', () => {
+    const report = commandReportFixture();
+    blocked(report);
+    expect(validate(report), JSON.stringify(validate.errors)).to.equal(true);
+    errored(report);
+    expect(validate(report), JSON.stringify(validate.errors)).to.equal(true);
+  });
+  it('permits real null metadata and incomplete totals without guessing them', () => {
+    const report = commandReportFixture();
+    errored(report);
+    report.flows[0].versionCount = null;
+    report.flows[0].limitPercent = null;
+    Object.assign(report.flows[0].versions[0], {
+      createdDate: null,
+      createdById: null,
+      lastModifiedDate: null,
+      ageDays: null,
+    });
+    expect(validate(report), JSON.stringify(validate.errors)).to.equal(true);
+  });
+  it('accepts a zero configured limit only with null percentage', () => {
+    const report = commandReportFixture();
+    report.versionLimit = 0;
+    expect(validate(report)).to.equal(false);
+    report.flows[0].limitPercent = null;
+    expect(validate(report), JSON.stringify(validate.errors)).to.equal(true);
+  });
+  it('rejects contradictory eligibility outcomes', () => {
+    const report = commandReportFixture();
+    report.flows[0].versions[0].deletable = false;
+    expect(validate(report)).to.equal(false);
+    blocked(report);
+    report.flows[0].versions[0].deletable = true;
+    expect(validate(report)).to.equal(false);
+    errored(report);
+    report.flows[0].versions[0].deletable = true;
+    expect(validate(report)).to.equal(false);
+  });
+  it('rejects missing, negative or null success counts', () => {
+    const report = commandReportFixture();
+    report.flows[0].versions[0].referenceCount = -1;
+    expect(validate(report)).to.equal(false);
+    report.flows[0].versions[0].referenceCount = null;
+    expect(validate(report)).to.equal(false);
+    delete (report.flows[0].versions[0] as unknown as Record<string, unknown>).failedInterviewCount;
+    expect(validate(report)).to.equal(false);
+  });
+  it('rejects obsolete format6 arrays and synthesized assessment/evidence fields', () => {
+    for (const field of ['rows', 'assessmentErrors', 'countErrors', 'capacityErrors']) {
+      const report = commandReportFixture();
+      Object.assign(report, { [field]: [] });
+      expect(validate(report), field).to.equal(false);
+    }
+    for (const field of ['assessment', 'evidence', 'c1Counts', 'countError', 'capacityError']) {
+      const report = commandReportFixture();
+      Object.assign(report.flows[0].versions[0], { [field]: [] });
+      expect(validate(report), field).to.equal(false);
+    }
+    const report = commandReportFixture();
+    Object.assign(report, { contractVersion: '6' });
+    expect(validate(report)).to.equal(false);
+  });
+  it('validates a preserved server truncation flag without asserting a complete org total', () => {
+    const report = commandReportFixture();
+    report.listTruncated = true;
+    report.candidateVersionCount = 2000;
+    expect(validate(report), JSON.stringify(validate.errors)).to.equal(true);
+    expect(report).not.to.have.property('totalVersions');
+  });
+});
diff --git a/test/commands/flow/version/prune.test.ts b/test/commands/flow/version/prune.test.ts
new file mode 100644
index 0000000..99854ad
--- /dev/null
+++ b/test/commands/flow/version/prune.test.ts
@@ -0,0 +1,376 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { readFileSync } from 'node:fs';
+import Ajv from 'ajv';
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { Org } from '@salesforce/core';
+import { stubSfCommandUx } from '@salesforce/sf-plugins-core';
+import FlowVersionPrune, {
+  formatVersionPruneReport,
+  type FlowVersionPruneCommandReport,
+} from '../../../../src/commands/flow/version/prune.js';
+import {
+  FlowVersionRetentionService,
+  type RetentionPlan,
+  type RetentionExecution,
+} from '../../../../src/services/flowVersionRetention.js';
+import { ConfirmationPrompt } from '../../../../src/ux/confirmation.js';
+
+const validateReport = new Ajv({ allErrors: true }).compile(
+  JSON.parse(readFileSync(new URL('../../../../schemas/flow-version-prune.json', import.meta.url), 'utf8')) as object
+);
+const fixture = (): RetentionPlan => ({
+  orgId: '00D000000000001EAA',
+  generatedAt: '2026-10-27T00:00:00Z',
+  scope: { all: false, flowName: 'Invoice', namespace: null, allNamespaces: true },
+  policy: { keepLatest: 5, olderThanDays: 90 },
+  flows: [
+    {
+      definitionId: '300xx000000bojNAAQ',
+      apiName: 'Invoice',
+      label: 'Invoice',
+      versionCount: 6,
+      limitPercent: 12,
+      versions: [
+        {
+          versionId: '301xx000003Ga19AAC',
+          versionNumber: 1,
+          versionName: null,
+          status: 'Draft',
+          createdDate: '2026-01-01T00:00:00Z',
+          ageDays: 299,
+          createdById: null,
+          createdByName: null,
+          lastModifiedDate: null,
+          statusChangeDate: null,
+          referenceCount: 0,
+          pausedInterviewCount: 0,
+          failedInterviewCount: 0,
+          deletable: true,
+          outcome: 'PASS',
+          reasonCode: null,
+          message: null,
+          disposition: 'CANDIDATE',
+          reasons: [{ code: 'RETENTION_CANDIDATE', message: 'Meets retention policy.' }],
+        },
+      ],
+    },
+  ],
+});
+const execution = (plan: RetentionPlan): RetentionExecution => ({
+  outcome: 'SUCCEEDED',
+  warnings: [],
+  results: plan.flows[0].versions.map((row) => ({
+    definitionId: plan.flows[0].definitionId,
+    versionId: row.versionId,
+    flowName: plan.flows[0].apiName,
+    namespace: null,
+    versionNumber: row.versionNumber,
+    status: row.status,
+    assessment: { versionId: row.versionId, outcome: 'PASS', reasonCode: null, message: null, evidence: [] },
+    error: null,
+    state: 'SUCCEEDED',
+    targetDeleted: true,
+    source: 'TOOLING',
+  })),
+});
+
+describe('flow version prune command', () => {
+  const sandbox = sinon.createSandbox();
+  const args = ['--target-org', 'source', '--flow', 'Invoice'];
+  let plan: RetentionPlan;
+  let deletion: RetentionExecution;
+  let planStub: sinon.SinonStub;
+  let execute: sinon.SinonStub;
+  let confirm: sinon.SinonStub;
+  let log: sinon.SinonStub;
+  let logJson: sinon.SinonStub;
+  let getConnection: sinon.SinonStub;
+  let originalExitCode: typeof process.exitCode;
+  let originalTTY: PropertyDescriptor | undefined;
+  const interactive = (value: boolean): void => {
+    Object.defineProperty(process.stdin, 'isTTY', { configurable: true, value });
+  };
+  const error = async (commandArgs: string[]): Promise<unknown> => {
+    let caught: unknown;
+    try {
+      await FlowVersionPrune.run(commandArgs);
+    } catch (item) {
+      caught = item;
+    }
+    expect(caught).to.be.instanceOf(Error);
+    return caught;
+  };
+
+  beforeEach(() => {
+    originalExitCode = process.exitCode;
+    process.exitCode = undefined;
+    originalTTY = Object.getOwnPropertyDescriptor(process.stdin, 'isTTY');
+    interactive(false);
+    plan = fixture();
+    deletion = execution(plan);
+    ({ log, logJson } = stubSfCommandUx(sandbox));
+    confirm = sandbox.stub(ConfirmationPrompt.prototype, 'confirm').resolves(false);
+    getConnection = sandbox.stub().returns({ getApiVersion: () => '67.0' });
+    sandbox.stub(Org, 'create').resolves({
+      getConnection,
+      getUsername: () => 'unit@example.com',
+    } as unknown as Org);
+    planStub = sandbox.stub(FlowVersionRetentionService.prototype, 'plan').resolves(plan);
+    execute = sandbox.stub(FlowVersionRetentionService.prototype, 'execute').resolves(deletion);
+  });
+  afterEach(() => {
+    sandbox.restore();
+    process.exitCode = originalExitCode;
+    if (originalTTY) Object.defineProperty(process.stdin, 'isTTY', originalTTY);
+    else Reflect.deleteProperty(process.stdin, 'isTTY');
+  });
+
+  it('defaults to preview with PRD defaults and performs no confirmation or execution', async () => {
+    const result = await FlowVersionPrune.run(args);
+    expect(planStub.firstCall.args).to.deep.equal([{ flowName: 'Invoice' }, { keepLatest: 5, olderThanDays: 90 }]);
+    expect(result).to.include({ dryRun: true, confirmed: false, outcome: 'PREVIEWED', deletion: null });
+    expect(confirm.called || execute.called).to.equal(false);
+    expect(String(log.firstCall.args[0])).to.include('No deletion requests were sent.');
+  });
+
+  it('returns JSON preview without human output even in noninteractive mode', async () => {
+    const result = await FlowVersionPrune.run([...args, '--dry-run', '--json']);
+    expect(result.dryRun).to.equal(true);
+    expect(confirm.called || execute.called || log.called).to.equal(false);
+    expect(logJson.calledOnce).to.equal(true);
+    expect(validateReport(result), JSON.stringify(validateReport.errors)).to.equal(true);
+  });
+
+  it('passes arbitrary scope and configurable retention without prefiltering C1', async () => {
+    await FlowVersionPrune.run(['-o', 'source', '--all', '--keep-latest', '7', '--older-than', '45d']);
+    expect(planStub.firstCall.args).to.deep.equal([{ all: true }, { keepLatest: 7, olderThanDays: 45 }]);
+  });
+
+  it('uses the installed C1 client and consumes the later page before protecting latest and rollback versions', async () => {
+    planStub.restore();
+    const base = fixture().flows[0].versions[0];
+    const makeRow = (n: number, status: string, changed: string | null): object => {
+      const wire = structuredClone(base) as Partial<typeof base>;
+      delete wire.disposition;
+      delete wire.reasons;
+      return { ...wire, versionId: `30100000000000${n}AAA`, versionNumber: n, status, statusChangeDate: changed };
+    };
+    const page = (versions: object[], nextOffset: number | null): object => ({
+      contractVersion: '1',
+      versionLimit: 50,
+      returnedVersionCount: versions.length,
+      candidateVersionCount: 4,
+      listTruncated: false,
+      nextOffset,
+      flows: [
+        {
+          definitionId: '300xx000000bojNAAQ',
+          apiName: 'Invoice',
+          label: 'Invoice',
+          versionCount: 4,
+          limitPercent: 8,
+          versions,
+        },
+      ],
+    });
+    const request = sandbox.stub();
+    request
+      .onFirstCall()
+      .resolves(page([makeRow(1, 'Obsolete', '2026-02-01T00:00:00Z'), makeRow(2, 'Draft', null)], 100));
+    request
+      .onSecondCall()
+      .resolves(page([makeRow(3, 'Obsolete', '2026-03-01T00:00:00Z'), makeRow(4, 'Draft', null)], null));
+    getConnection.returns({
+      getApiVersion: () => '67.0',
+      getAuthInfoFields: () => ({ orgId: '00D000000000001EAA' }),
+      request,
+    });
+    const result = await FlowVersionPrune.run([...args, '--keep-latest', '1', '--older-than', '0d', '--json']);
+    expect(request.callCount).to.equal(2);
+    expect(result.plan.flows[0].versions.map((item) => item.disposition)).to.deep.equal([
+      'CANDIDATE',
+      'CANDIDATE',
+      'KEPT',
+      'KEPT',
+    ]);
+    for (const call of request.getCalls()) {
+      const req = call.args[0] as { method: string; url: string; body: string };
+      const body = JSON.parse(req.body) as Record<string, unknown>;
+      expect(req).to.include({ method: 'POST', url: '/connect/interaction/flow-versions/list' });
+      expect(body).not.to.have.property('status');
+      expect(body).not.to.have.property('olderThanDays');
+      expect(body).not.to.have.property('deletable');
+    }
+    expect(JSON.parse((request.secondCall.args[0] as { body: string }).body)).to.include({ offset: 100 });
+    expect(execute.called || confirm.called).to.equal(false);
+    expect(validateReport(result), JSON.stringify(validateReport.errors)).to.equal(true);
+  });
+
+  it('requires exactly one scope and rejects conflicting execution options before planning', async () => {
+    await error(['-o', 'source']);
+    await error([...args, '--all']);
+    for (const flags of [
+      ['--yes', '--dry-run'],
+      ['--execute', '--dry-run'],
+      ['--execute', '--yes'],
+    ]) {
+      // eslint-disable-next-line no-await-in-loop -- Command tests share process state and must run sequentially.
+      await error([...args, ...flags]);
+    }
+    expect(planStub.called || execute.called).to.equal(false);
+  });
+
+  it('validates policy options before planning', async () => {
+    await error([...args, '--keep-latest', '0']);
+    await error([...args, '--older-than', '90']);
+    expect(planStub.called).to.equal(false);
+  });
+
+  it('rejects noninteractive and JSON --execute without silently falling back to deletion', async () => {
+    await error([...args, '--execute']);
+    interactive(true);
+    await error([...args, '--execute', '--json']);
+    expect(planStub.called || execute.called || confirm.called).to.equal(false);
+  });
+
+  it('displays the complete plan and allows one minute, default no, for interactive confirmation', async () => {
+    interactive(true);
+    const result = await FlowVersionPrune.run([...args, '--execute']);
+    expect(log.calledBefore(confirm)).to.equal(true);
+    expect(confirm.firstCall.args[0]).to.include({ ms: 60_000, defaultAnswer: false });
+    expect(result).to.include({ outcome: 'CANCELLED', confirmed: false, deletion: null });
+    expect(execute.called).to.equal(false);
+  });
+
+  it('executes only after explicit interactive approval', async () => {
+    interactive(true);
+    confirm.resolves(true);
+    const result = await FlowVersionPrune.run([...args, '--execute']);
+    expect(execute.calledOnceWithExactly(plan)).to.equal(true);
+    expect(confirm.calledBefore(execute)).to.equal(true);
+    expect(result).to.include({ outcome: 'SUCCEEDED', confirmed: true, dryRun: false });
+    expect(validateReport(result), JSON.stringify(validateReport.errors)).to.equal(true);
+  });
+
+  it('executes exact planned targets with --yes and no prompt in JSON/noninteractive mode', async () => {
+    const result = await FlowVersionPrune.run([...args, '--yes', '--json']);
+    expect(confirm.called || log.called).to.equal(false);
+    expect(execute.calledOnceWithExactly(plan)).to.equal(true);
+    expect(result.deletion).to.equal(deletion);
+    expect(validateReport(result), JSON.stringify(validateReport.errors)).to.equal(true);
+  });
+
+  it('keeps completed preview exit zero even when it displays backend blocked/error rows', async () => {
+    Object.assign(plan.flows[0].versions[0], {
+      disposition: 'ERROR',
+      outcome: 'ERROR',
+      deletable: false,
+      reasonCode: 'OPERATIONAL',
+    });
+    const result = await FlowVersionPrune.run(args);
+    expect(result.outcome).to.equal('PREVIEWED');
+    expect(process.exitCode).not.to.equal(1);
+    expect(process.exitCode).not.to.equal(2);
+  });
+
+  it('returns exit 1 for a blocker, and 2 for a failed or uncertain execution', async () => {
+    Object.assign(deletion.results[0], {
+      state: 'BLOCKED',
+      targetDeleted: false,
+      error: { code: 'ACTIVE_VERSION', message: 'ACTIVE_VERSION' },
+    });
+    await FlowVersionPrune.run([...args, '--yes']);
+    expect(process.exitCode).to.equal(1);
+    Object.assign(deletion.results[0], { state: 'FAILED' });
+    await FlowVersionPrune.run([...args, '--yes']);
+    expect(process.exitCode).to.equal(2);
+    Object.assign(deletion.results[0], { state: 'UNKNOWN', targetDeleted: null });
+    await FlowVersionPrune.run([...args, '--yes']);
+    expect(process.exitCode).to.equal(2);
+  });
+
+  it('aligns overall outcome and exit code for blocked or errored rows outside the candidate set', async () => {
+    deletion.results = [];
+    Object.assign(plan.flows[0].versions[0], {
+      disposition: 'BLOCKED',
+      outcome: 'BLOCKED',
+      deletable: false,
+      reasonCode: 'PAUSED_INTERVIEWS',
+      message: 'PAUSED_INTERVIEWS (1)',
+    });
+    const blocked = await FlowVersionPrune.run([...args, '--yes']);
+    expect(blocked.outcome).to.equal('FAILED');
+    expect(process.exitCode).to.equal(1);
+    Object.assign(plan.flows[0].versions[0], { disposition: 'ERROR', outcome: 'ERROR', reasonCode: 'OPERATIONAL' });
+    const failed = await FlowVersionPrune.run([...args, '--yes']);
+    expect(failed.outcome).to.equal('FAILED');
+    expect(process.exitCode).to.equal(2);
+  });
+
+  it('reports PARTIAL when a candidate succeeds but another retention-eligible row was blocked at preview', async () => {
+    plan.flows[0].versions.push({
+      ...plan.flows[0].versions[0],
+      versionId: '301000000000002AAA',
+      versionNumber: 2,
+      disposition: 'BLOCKED',
+      outcome: 'BLOCKED',
+      deletable: false,
+      reasonCode: 'PAUSED_INTERVIEWS',
+      message: 'PAUSED_INTERVIEWS (1)',
+    });
+    const result = await FlowVersionPrune.run([...args, '--yes']);
+    expect(result.outcome).to.equal('PARTIAL');
+    expect(process.exitCode).to.equal(1);
+    expect(result.deletion?.outcome).to.equal('SUCCEEDED');
+  });
+
+  it('does not fail cleanup for a young protected row whose backend assessment is ERROR', async () => {
+    Object.assign(plan.flows[0].versions[0], {
+      ageDays: 2,
+      disposition: 'KEPT',
+      outcome: 'ERROR',
+      deletable: false,
+      reasonCode: 'OPERATIONAL',
+      reasons: [{ code: 'AGE_THRESHOLD', message: 'Keep younger versions.' }],
+    });
+    deletion.results = [];
+    const result = await FlowVersionPrune.run([...args, '--yes']);
+    expect(result.outcome).to.equal('SUCCEEDED');
+    expect(process.exitCode).to.equal(0);
+    expect(result.plan.flows[0].versions[0].outcome).to.equal('ERROR');
+  });
+
+  it('sanitizes controls in console output while leaving structured data unchanged', async () => {
+    const result = await FlowVersionPrune.run(args);
+    result.targetOrg = '\u001b[31morg\u001b[0m\u202e\nspoof';
+    const output = formatVersionPruneReport(result);
+    expect(output).not.to.include('\u001b');
+    expect(output).not.to.include('\u202e');
+    expect(output).to.include('org  spoof');
+    expect(result.targetOrg).to.include('\u001b');
+  });
+
+  it('enforces stable JSON version and no unexpected report properties', async () => {
+    const result: FlowVersionPruneCommandReport = await FlowVersionPrune.run(args);
+    expect(validateReport(result), JSON.stringify(validateReport.errors)).to.equal(true);
+    expect(validateReport({ ...result, contractVersion: '2' })).to.equal(false);
+    expect(validateReport({ ...result, fakeCounts: [] })).to.equal(false);
+    expect(validateReport({ ...result, dryRun: false })).to.equal(false);
+  });
+});
diff --git a/test/services/dependencyService.test.ts b/test/services/dependencyService.test.ts
new file mode 100644
index 0000000..bab0226
--- /dev/null
+++ b/test/services/dependencyService.test.ts
@@ -0,0 +1,554 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { expect } from 'chai';
+import { DependencyService, ToolingQueryClient } from '../../src/services/dependencyService.js';
+
+const CHILD_NAME = 'FlowDependency_POC_Child';
+const PARENT_NAME = 'FlowDependency_POC_Parent';
+const CHILD_DEFINITION_ID = '300xx000000bojNAAQ';
+const PARENT_DEFINITION_ID = '300xx000000bojOAAQ';
+const CHILD_VERSION_ID = '301xx000003Ga19AAC';
+const PARENT_VERSION_ID = '301xx000003Ga1AAAS';
+
+type DefinitionRecord = {
+  Id: string;
+  DeveloperName: string;
+  NamespacePrefix: string | null;
+  ActiveVersionId: string | null;
+  LatestVersionId: string | null;
+};
+
+type FlowRecord = {
+  Id: string;
+  DefinitionId: string;
+  VersionNumber: number;
+  Status: unknown;
+  Metadata: unknown;
+};
+
+type DependencyRecord = {
+  MetadataComponentId: string;
+  MetadataComponentName: string;
+  MetadataComponentType: string;
+  MetadataComponentNamespace: string | null;
+  RefMetadataComponentId: string;
+  RefMetadataComponentName: string;
+  RefMetadataComponentType: string;
+  RefMetadataComponentNamespace: string | null;
+};
+
+type MockOptions = {
+  definitions?: Record<string, DefinitionRecord[]>;
+  versions?: Record<string, FlowRecord[]>;
+  dependencyRecords?: DependencyRecord[];
+  dependencyError?: Error;
+  dependencyFailureFor?: RegExp;
+  dependencyDone?: boolean;
+  dependencyTotalSize?: number;
+  versionError?: Error;
+};
+
+const subflowElement = {
+  name: 'Call_POC_Child',
+  flowName: CHILD_NAME,
+  inputAssignments: [{ name: 'inputText', value: { stringValue: 'Flow dependency POC' } }],
+  outputAssignments: [{ name: 'outputText', assignToReference: 'childResult' }],
+};
+
+const childDefinition: DefinitionRecord = {
+  Id: CHILD_DEFINITION_ID,
+  DeveloperName: CHILD_NAME,
+  NamespacePrefix: null,
+  ActiveVersionId: null,
+  LatestVersionId: CHILD_VERSION_ID,
+};
+
+const parentDefinition: DefinitionRecord = {
+  Id: PARENT_DEFINITION_ID,
+  DeveloperName: PARENT_NAME,
+  NamespacePrefix: null,
+  ActiveVersionId: null,
+  LatestVersionId: PARENT_VERSION_ID,
+};
+
+const childVersion: FlowRecord = {
+  Id: CHILD_VERSION_ID,
+  DefinitionId: CHILD_DEFINITION_ID,
+  VersionNumber: 1,
+  Status: 'Draft',
+  Metadata: { subflows: [] },
+};
+
+const parentVersion: FlowRecord = {
+  Id: PARENT_VERSION_ID,
+  DefinitionId: PARENT_DEFINITION_ID,
+  VersionNumber: 1,
+  Status: 'Draft',
+  Metadata: { subflows: [subflowElement] },
+};
+
+const dependencyRecord: DependencyRecord = {
+  MetadataComponentId: PARENT_DEFINITION_ID,
+  MetadataComponentName: PARENT_NAME,
+  MetadataComponentType: 'FlowDefinition',
+  MetadataComponentNamespace: null,
+  RefMetadataComponentId: CHILD_DEFINITION_ID,
+  RefMetadataComponentName: CHILD_NAME,
+  RefMetadataComponentType: 'FlowDefinition',
+  RefMetadataComponentNamespace: null,
+};
+
+function mockQueryClient(options: MockOptions = {}): { client: ToolingQueryClient; queries: string[] } {
+  const queries: string[] = [];
+  const definitions = options.definitions ?? { [CHILD_NAME]: [childDefinition], [PARENT_NAME]: [parentDefinition] };
+  const versions = options.versions ?? {
+    [CHILD_VERSION_ID]: [childVersion],
+    [PARENT_VERSION_ID]: [parentVersion],
+  };
+  const client: ToolingQueryClient = {
+    async query<T>(soql: string): Promise<{ records: T[]; totalSize?: number; done?: boolean }> {
+      queries.push(soql);
+      let records: unknown[];
+      if (/FROM MetadataComponentDependency\b/i.test(soql)) {
+        if (options.dependencyError && (!options.dependencyFailureFor || options.dependencyFailureFor.test(soql))) {
+          throw options.dependencyError;
+        }
+        const predicate = /WHERE\s+(MetadataComponentId|RefMetadataComponentId)\s*=\s*'([^']+)'/i.exec(soql);
+        if (!predicate) throw new Error(`Unbounded dependency query in test: ${soql}`);
+        const field = predicate[1] as 'MetadataComponentId' | 'RefMetadataComponentId';
+        records = (options.dependencyRecords ?? []).filter((record) => record[field] === predicate[2]);
+        return {
+          records: records as T[],
+          totalSize: options.dependencyTotalSize ?? records.length,
+          done: options.dependencyDone ?? true,
+        };
+      }
+      if (/FROM FlowDefinition\b/i.test(soql)) {
+        const name = /DeveloperName\s*=\s*'([^']+)'/i.exec(soql)?.[1];
+        if (!name) throw new Error(`Unbounded FlowDefinition query in test: ${soql}`);
+        records = definitions[name] ?? [];
+      } else if (/FROM Flow\b/i.test(soql)) {
+        if (options.versionError) throw options.versionError;
+        const id = /WHERE\s+Id\s*=\s*'([^']+)'/i.exec(soql)?.[1];
+        if (!id) throw new Error(`Unbounded Flow query in test: ${soql}`);
+        records = versions[id] ?? [];
+      } else {
+        throw new Error(`Unexpected API query in test: ${soql}`);
+      }
+      return { records: records as T[], totalSize: records.length, done: true };
+    },
+  };
+  return { client, queries };
+}
+
+async function expectFailure(action: () => Promise<unknown>, message: RegExp): Promise<void> {
+  let failure: unknown;
+  try {
+    await action();
+  } catch (error) {
+    failure = error;
+  }
+  expect(failure, 'expected the analysis to reject').to.be.instanceOf(Error);
+  expect((failure as Error).message).to.match(message);
+}
+
+describe('DependencyService', () => {
+  it('should discover a Draft parent-to-child relationship when the dependency API returns no rows', async () => {
+    const { client } = mockQueryClient();
+    const result = await new DependencyService(client).analyze({ flowName: PARENT_NAME });
+
+    expect(result.root).to.include({
+      flowName: PARENT_NAME,
+      namespace: null,
+      definitionId: PARENT_DEFINITION_ID,
+      versionId: PARENT_VERSION_ID,
+      versionNumber: 1,
+      status: 'Draft',
+    });
+    expect(result.relationships).to.have.length(1);
+    expect(result.relationships[0]).to.include({
+      direction: 'outgoing',
+      callerType: 'Flow',
+      callerName: PARENT_NAME,
+      callerVersion: 1,
+      callerStatus: 'Draft',
+      targetType: 'FlowDefinition',
+      targetName: CHILD_NAME,
+      elementName: 'Call_POC_Child',
+      evidence: 'Flow.Metadata',
+    });
+    expect(result.mcd.status).to.equal('success');
+    expect(result.mcd.reportedEdges).to.deep.equal([]);
+  });
+
+  it('should identify a parent as an incoming caller only within explicitly scanned Flows', async () => {
+    const { client } = mockQueryClient();
+    const result = await new DependencyService(client).analyze({ flowName: CHILD_NAME, scanFlows: [PARENT_NAME] });
+
+    expect(result.scannedFlows.map((flow) => flow.flowName)).to.have.members([CHILD_NAME, PARENT_NAME]);
+    expect(result.relationships).to.have.length(1);
+    expect(result.relationships[0]).to.include({
+      direction: 'incoming',
+      callerName: PARENT_NAME,
+      callerVersion: 1,
+      callerStatus: 'Draft',
+      targetName: CHILD_NAME,
+      evidence: 'Flow.Metadata',
+    });
+    expect(result.root.versionId).to.equal(CHILD_VERSION_ID);
+  });
+
+  it('should declare its bounded scope and explicitly disclose that Apex source was not scanned', async () => {
+    const { client } = mockQueryClient();
+    const result = await new DependencyService(client).analyze({ flowName: CHILD_NAME });
+
+    expect(result.scope).to.include({
+      flowMetadata: 'explicit-flows-only',
+      orgWideComplete: false,
+      apexSourceScanned: false,
+    });
+    expect(result.scope.requestedFlowNames).to.deep.equal([CHILD_NAME]);
+    expect(result.warnings.join(' ')).to.match(/apex/i);
+    expect(result.warnings.join(' ')).to.match(/scope|complete|explicit|all.*caller/i);
+    expect(result.relationships).to.deep.equal([]);
+  });
+
+  it('should issue only bounded read queries and never activate or execute a Flow', async () => {
+    const { client, queries } = mockQueryClient();
+    await new DependencyService(client).analyze({ flowName: CHILD_NAME, scanFlows: [PARENT_NAME] });
+
+    expect(queries).not.to.be.empty;
+    for (const query of queries) {
+      expect(query).to.match(/^SELECT /i);
+      expect(query).to.match(/\bWHERE\b/i);
+      expect(query).to.match(/\bLIMIT\s+\d+$/i);
+      expect(query).not.to.match(/\b(?:UPDATE|DELETE|INSERT|UPSERT|EXECUTE|ACTIVATE)\b/i);
+      if (/FROM FlowDefinition\b/i.test(query)) expect(query).to.match(/DeveloperName\s*=/i);
+      if (/FROM Flow\b/i.test(query)) expect(query).to.match(/WHERE\s+Id\s*=/i);
+    }
+    expect(queries.some((query) => /FROM ApexClass\b/i.test(query))).to.equal(false);
+  });
+
+  it('should default to latest and retain Draft status without requiring an active version', async () => {
+    const { client } = mockQueryClient();
+    const result = await new DependencyService(client).analyze({ flowName: CHILD_NAME });
+
+    expect(result.versionPolicy).to.equal('latest');
+    expect(result.root.status).to.equal('Draft');
+    expect(result.root.versionId).to.equal(CHILD_VERSION_ID);
+  });
+
+  it('should use the selected active version rather than silently using latest', async () => {
+    const activeId = '301xx000003Ga18AAC';
+    const { client, queries } = mockQueryClient({
+      definitions: { [CHILD_NAME]: [{ ...childDefinition, ActiveVersionId: activeId }] },
+      versions: { [activeId]: [{ ...childVersion, Id: activeId, Status: 'Active', VersionNumber: 2 }] },
+    });
+    const result = await new DependencyService(client).analyze({ flowName: CHILD_NAME, versionPolicy: 'active' });
+
+    expect(result.versionPolicy).to.equal('active');
+    expect(result.root).to.include({ versionId: activeId, versionNumber: 2, status: 'Active' });
+    expect(queries.filter((query) => /FROM Flow\b/i.test(query))[0]).to.include(activeId);
+  });
+
+  it('should reject active policy when the selected Flow has no active version', async () => {
+    const { client, queries } = mockQueryClient();
+    await expectFailure(
+      () => new DependencyService(client).analyze({ flowName: CHILD_NAME, versionPolicy: 'active' }),
+      /active/i
+    );
+    expect(queries.some((query) => /FROM Flow\b/i.test(query))).to.equal(false);
+  });
+
+  it('should reject a missing root instead of reporting zero dependencies', async () => {
+    const { client } = mockQueryClient({ definitions: {} });
+    await expectFailure(() => new DependencyService(client).analyze({ flowName: CHILD_NAME }), /not found|no .*flow/i);
+  });
+
+  it('should reject an ambiguous root rather than selecting an arbitrary definition', async () => {
+    const { client } = mockQueryClient({ definitions: { [CHILD_NAME]: [childDefinition, childDefinition] } });
+    await expectFailure(
+      () => new DependencyService(client).analyze({ flowName: CHILD_NAME }),
+      /ambiguous|multiple|more than one/i
+    );
+  });
+
+  it('should reject a missing selected version instead of reporting zero dependencies', async () => {
+    const { client } = mockQueryClient({ versions: {} });
+    await expectFailure(
+      () => new DependencyService(client).analyze({ flowName: CHILD_NAME }),
+      /version|not found|no .*flow/i
+    );
+  });
+
+  it('should reject latest policy when no latest version is available', async () => {
+    const { client, queries } = mockQueryClient({
+      definitions: { [CHILD_NAME]: [{ ...childDefinition, LatestVersionId: null }] },
+    });
+    await expectFailure(() => new DependencyService(client).analyze({ flowName: CHILD_NAME }), /latest/i);
+    expect(queries.some((query) => /FROM Flow\b/i.test(query))).to.equal(false);
+  });
+
+  it('should reject an invalid definition ID returned by the API', async () => {
+    const { client } = mockQueryClient({ definitions: { [CHILD_NAME]: [{ ...childDefinition, Id: "bad'id" }] } });
+    await expectFailure(() => new DependencyService(client).analyze({ flowName: CHILD_NAME }), /invalid.*id/i);
+  });
+
+  it('should reject an invalid selected version ID returned by the API', async () => {
+    const { client } = mockQueryClient({
+      definitions: { [CHILD_NAME]: [{ ...childDefinition, LatestVersionId: "bad'id" }] },
+    });
+    await expectFailure(() => new DependencyService(client).analyze({ flowName: CHILD_NAME }), /invalid.*id/i);
+  });
+
+  it('should reject a returned version belonging to a different Flow definition', async () => {
+    const { client } = mockQueryClient({
+      versions: { [CHILD_VERSION_ID]: [{ ...childVersion, DefinitionId: PARENT_DEFINITION_ID }] },
+    });
+    await expectFailure(() => new DependencyService(client).analyze({ flowName: CHILD_NAME }), /match|definition/i);
+  });
+
+  for (const versionNumber of [0, -1, 1.5]) {
+    it(`should reject incomplete version identity with version number ${versionNumber}`, async () => {
+      const { client } = mockQueryClient({
+        versions: { [CHILD_VERSION_ID]: [{ ...childVersion, VersionNumber: versionNumber }] },
+      });
+      await expectFailure(() => new DependencyService(client).analyze({ flowName: CHILD_NAME }), /version identity/i);
+    });
+  }
+
+  it('should reject incomplete version identity when status is absent', async () => {
+    const { client } = mockQueryClient({
+      versions: { [CHILD_VERSION_ID]: [{ ...childVersion, Status: undefined }] },
+    });
+    await expectFailure(() => new DependencyService(client).analyze({ flowName: CHILD_NAME }), /version identity/i);
+  });
+
+  it('should propagate a required Flow read failure', async () => {
+    const { client } = mockQueryClient({ versionError: new Error('Required Flow read denied') });
+    await expectFailure(
+      () => new DependencyService(client).analyze({ flowName: CHILD_NAME }),
+      /Required Flow read denied/i
+    );
+  });
+
+  it('should support a singleton subflow value without losing the relationship', async () => {
+    const { client } = mockQueryClient({
+      versions: { [PARENT_VERSION_ID]: [{ ...parentVersion, Metadata: { subflows: subflowElement } }] },
+    });
+    const result = await new DependencyService(client).analyze({ flowName: PARENT_NAME });
+
+    expect(result.relationships).to.have.length(1);
+    expect(result.relationships[0]).to.include({ targetName: CHILD_NAME, elementName: 'Call_POC_Child' });
+  });
+
+  it('should handle null subflows as no declared subflow elements', async () => {
+    const { client } = mockQueryClient({
+      versions: { [CHILD_VERSION_ID]: [{ ...childVersion, Metadata: { subflows: null } }] },
+    });
+    const result = await new DependencyService(client).analyze({ flowName: CHILD_NAME });
+    expect(result.relationships).to.deep.equal([]);
+  });
+
+  it('should handle absent subflows as no declared subflow elements', async () => {
+    const { client } = mockQueryClient({
+      versions: { [CHILD_VERSION_ID]: [{ ...childVersion, Metadata: {} }] },
+    });
+    const result = await new DependencyService(client).analyze({ flowName: CHILD_NAME });
+    expect(result.relationships).to.deep.equal([]);
+  });
+
+  it('should read Flow Metadata serialized as a JSON object', async () => {
+    const { client } = mockQueryClient({
+      versions: { [PARENT_VERSION_ID]: [{ ...parentVersion, Metadata: JSON.stringify(parentVersion.Metadata) }] },
+    });
+    const result = await new DependencyService(client).analyze({ flowName: PARENT_NAME });
+    expect(result.relationships).to.have.length(1);
+    expect(result.relationships[0]).to.include({ targetName: CHILD_NAME, evidence: 'Flow.Metadata' });
+  });
+
+  for (const metadata of [null, [], 'not-json', '[]', 'null']) {
+    it(`should reject unreadable Flow Metadata ${JSON.stringify(
+      metadata
+    )} instead of reporting zero dependencies`, async () => {
+      const { client } = mockQueryClient({
+        versions: { [CHILD_VERSION_ID]: [{ ...childVersion, Metadata: metadata }] },
+      });
+      await expectFailure(
+        () => new DependencyService(client).analyze({ flowName: CHILD_NAME }),
+        /no readable Metadata|cannot be analyzed/i
+      );
+    });
+  }
+
+  it('should warn on a malformed subflow element while retaining readable relationships', async () => {
+    const { client } = mockQueryClient({
+      versions: {
+        [PARENT_VERSION_ID]: [{ ...parentVersion, Metadata: { subflows: [null, { flowName: '' }, subflowElement] } }],
+      },
+    });
+    const result = await new DependencyService(client).analyze({ flowName: PARENT_NAME });
+    expect(result.relationships).to.have.length(1);
+    expect(result.warnings.join(' ')).to.match(/unreadable subflow target/i);
+  });
+
+  it('should trim and deduplicate root and scan names before making queries', async () => {
+    const { client, queries } = mockQueryClient();
+    const result = await new DependencyService(client).analyze({
+      flowName: ` ${CHILD_NAME} `,
+      scanFlows: [CHILD_NAME, PARENT_NAME, ` ${PARENT_NAME} `],
+    });
+
+    expect(result.scope.requestedFlowNames).to.have.members([CHILD_NAME, PARENT_NAME]);
+    expect(result.scope.requestedFlowNames).to.have.length(2);
+    expect(result.scannedFlows).to.have.length(2);
+    expect(queries.filter((query) => /FROM FlowDefinition\b/i.test(query))).to.have.length(2);
+    expect(queries.filter((query) => /FROM Flow\b/i.test(query))).to.have.length(2);
+  });
+
+  for (const invalidName of ['', ' ', "MyFlow' OR Id != null", 'MyFlow\\', 'My Flow', 'MyFlow;DELETE']) {
+    it(`should reject invalid Flow name ${JSON.stringify(invalidName)} before querying`, async () => {
+      const { client, queries } = mockQueryClient();
+      await expectFailure(() => new DependencyService(client).analyze({ flowName: invalidName }), /name|invalid|flow/i);
+      expect(queries).to.deep.equal([]);
+    });
+  }
+
+  it('should reject an invalid explicit scan name before querying any Flow', async () => {
+    const { client, queries } = mockQueryClient();
+    await expectFailure(
+      () => new DependencyService(client).analyze({ flowName: CHILD_NAME, scanFlows: ["bad'name"] }),
+      /name|invalid|flow/i
+    );
+    expect(queries).to.deep.equal([]);
+  });
+
+  it('should bound the number of explicitly scanned Flows before querying', async () => {
+    const { client, queries } = mockQueryClient();
+    await expectFailure(
+      () =>
+        new DependencyService(client).analyze({
+          flowName: CHILD_NAME,
+          scanFlows: Array.from({ length: 20 }, (_, index) => `ExtraFlow_${index}`),
+        }),
+      /20|limit|maximum|many/i
+    );
+    expect(queries).to.deep.equal([]);
+  });
+
+  it('should constrain an unnamespaced root to null namespace', async () => {
+    const { client, queries } = mockQueryClient();
+    await new DependencyService(client).analyze({ flowName: CHILD_NAME });
+    const definitionQuery = queries.find((query) => /FROM FlowDefinition\b/i.test(query));
+    expect(definitionQuery).to.match(/NamespacePrefix\s*=\s*null/i);
+  });
+
+  it('should constrain a namespaced root to the requested namespace', async () => {
+    const { client, queries } = mockQueryClient({
+      definitions: { [CHILD_NAME]: [{ ...childDefinition, NamespacePrefix: 'acme' }] },
+    });
+    const result = await new DependencyService(client).analyze({ flowName: CHILD_NAME, namespace: 'acme' });
+    const definitionQuery = queries.find((query) => /FROM FlowDefinition\b/i.test(query));
+    expect(definitionQuery).to.match(/NamespacePrefix\s*=\s*'acme'/i);
+    expect(result.root.namespace).to.equal('acme');
+  });
+
+  it('should reject namespace injection before querying', async () => {
+    const { client, queries } = mockQueryClient();
+    await expectFailure(
+      () => new DependencyService(client).analyze({ flowName: CHILD_NAME, namespace: "acme' OR Id != null" }),
+      /namespace|name|invalid/i
+    );
+    expect(queries).to.deep.equal([]);
+  });
+
+  it('should report dependency API failure separately from an empty successful result', async () => {
+    const { client } = mockQueryClient({ dependencyError: new Error('Dependency API unavailable') });
+    const result = await new DependencyService(client).analyze({ flowName: PARENT_NAME });
+
+    expect(result.mcd.status).to.equal('failed');
+    expect(result.warnings.join(' ')).to.match(/Dependency API unavailable/);
+    expect(result.relationships).to.have.length(1);
+    expect(result.relationships[0].evidence).to.equal('Flow.Metadata');
+    expect(result.scope.orgWideComplete).to.equal(false);
+  });
+
+  it('should report partial dependency evidence when one API query fails and the others succeed', async () => {
+    const { client } = mockQueryClient({
+      dependencyError: new Error('One dependency query failed'),
+      dependencyFailureFor: new RegExp(`WHERE RefMetadataComponentId = '${CHILD_DEFINITION_ID}'`),
+    });
+    const result = await new DependencyService(client).analyze({ flowName: CHILD_NAME });
+
+    expect(result.mcd.status).to.equal('partial');
+    expect(result.mcd.queryCount).to.equal(4);
+    expect(result.warnings.join(' ')).to.match(/One dependency query failed/);
+  });
+
+  it('should preserve an API-reported Apex caller as supplementary incoming evidence without claiming a source scan', async () => {
+    const apexCaller = {
+      ...dependencyRecord,
+      MetadataComponentId: '01pxx000000AbCdAAK',
+      MetadataComponentName: 'CallsPocFlow',
+      MetadataComponentType: 'ApexClass',
+    };
+    const { client } = mockQueryClient({ dependencyRecords: [apexCaller] });
+    const result = await new DependencyService(client).analyze({ flowName: CHILD_NAME });
+
+    expect(result.relationships).to.have.length(1);
+    expect(result.relationships[0]).to.include({
+      direction: 'incoming',
+      callerType: 'ApexClass',
+      callerName: 'CallsPocFlow',
+      targetName: CHILD_NAME,
+      evidence: 'MetadataComponentDependency',
+    });
+    expect(result.scope.apexSourceScanned).to.equal(false);
+  });
+
+  it('should flag a saturated dependency query as incomplete without fetching the whole org', async () => {
+    const dependencyRecords = Array.from({ length: 200 }, (_, index) => ({
+      ...dependencyRecord,
+      MetadataComponentName: `Caller_${index}`,
+    }));
+    const { client, queries } = mockQueryClient({ dependencyRecords });
+    const result = await new DependencyService(client).analyze({ flowName: CHILD_NAME });
+
+    expect(result.mcd.status).to.equal('partial');
+    expect(result.mcd.limit).to.equal(200);
+    expect(result.warnings.join(' ')).to.match(/limit|truncat|incomplete|200/i);
+    expect(result.scope.orgWideComplete).to.equal(false);
+    expect(queries.filter((query) => /FROM MetadataComponentDependency\b/i.test(query))).to.have.length(4);
+  });
+
+  it('should flag a dependency API continuation response as incomplete without silently paging', async () => {
+    const { client, queries } = mockQueryClient({ dependencyRecords: [dependencyRecord], dependencyDone: false });
+    const result = await new DependencyService(client).analyze({ flowName: CHILD_NAME });
+
+    expect(result.mcd.status).to.equal('partial');
+    expect(result.warnings.join(' ')).to.match(/limit|incomplete|continu|partial|done/i);
+    expect(queries.filter((query) => /FROM MetadataComponentDependency\b/i.test(query))).to.have.length(4);
+  });
+
+  it('should preserve supplementary dependency API evidence and deduplicate repeated records', async () => {
+    const { client } = mockQueryClient({ dependencyRecords: [dependencyRecord, dependencyRecord] });
+    const result = await new DependencyService(client).analyze({ flowName: CHILD_NAME });
+
+    expect(result.mcd.reportedEdges).to.deep.equal([dependencyRecord]);
+    expect(result.mcd.queryCount).to.equal(4);
+    expect(result.mcd.status).to.equal('success');
+  });
+});
diff --git a/test/services/flowForceDeleteNative.test.ts b/test/services/flowForceDeleteNative.test.ts
new file mode 100644
index 0000000..f58e9b3
--- /dev/null
+++ b/test/services/flowForceDeleteNative.test.ts
@@ -0,0 +1,241 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { PassThrough } from 'node:stream';
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { Connection, type AuthInfo } from '@salesforce/core';
+import { ConnectFlowVersionForceDeleteClient, FlowVersionForceDeleteRequestError } from '@salesforce/flow-node';
+
+const token = 'unit-only-opaque-confirmation-never-log';
+const orgId = '00D000000000001EAA';
+type Reply = { statusCode: number; body: string } | Error | undefined;
+type NativeRequest = { method: string; url: string; body?: string; headers?: Record<string, string> };
+type LoggerShape = { getRawLogger(): { debug(...values: unknown[]): unknown } };
+
+// Native SDK parsing, request logging and session refresh; all HTTP responses are in-memory fixtures.
+describe('C6 force deletion through the installed authenticated Connection', () => {
+  const sandbox = sinon.createSandbox();
+  afterEach(() => sandbox.restore());
+
+  const setup = async (
+    replies: Reply[]
+  ): Promise<{
+    connection: Connection;
+    adapter: ConnectFlowVersionForceDeleteClient;
+    request: sinon.SinonStub;
+    originalLogger: LoggerShape;
+    originalTransport: Connection['_transport'];
+    debug: sinon.SinonSpy;
+  }> => {
+    const connection = new Connection({
+      authInfo: {
+        getUsername: () => 'c6-unit-only@example.invalid',
+        getFields: () => ({ orgId }),
+      } as AuthInfo,
+      connectionOptions: {
+        instanceUrl: 'https://flow-c6-unit-test.invalid',
+        accessToken: 'unit-only-not-a-credential',
+        version: '67.0',
+      },
+    });
+    await connection.init();
+    const originalLogger = (connection as unknown as { logger: LoggerShape }).logger;
+    const debug = sandbox.spy(originalLogger.getRawLogger(), 'debug');
+    Object.assign(connection, { _logLevel: 'DEBUG' });
+    // eslint-disable-next-line no-underscore-dangle
+    const originalTransport = connection._transport;
+    const request = sandbox.stub(originalTransport, 'httpRequest').callsFake(() => {
+      if (replies.length === 0) throw new Error('Unexpected native HTTP request');
+      const reply = replies.shift();
+      const promise =
+        reply instanceof Error
+          ? Promise.reject(reply)
+          : Promise.resolve(
+              reply === undefined
+                ? undefined
+                : { statusCode: reply.statusCode, body: reply.body, headers: { 'content-type': 'application/json' } }
+            );
+      return Object.assign(promise, { stream: () => new PassThrough() }) as unknown as ReturnType<
+        typeof originalTransport.httpRequest
+      >;
+    });
+    return {
+      connection,
+      originalLogger,
+      originalTransport,
+      request,
+      debug,
+      adapter: new ConnectFlowVersionForceDeleteClient(connection),
+    };
+  };
+
+  const caught = async (operation: Promise<unknown>): Promise<FlowVersionForceDeleteRequestError> => {
+    let failure: unknown;
+    try {
+      await operation;
+    } catch (error) {
+      failure = error;
+    }
+    expect(failure).to.be.instanceOf(FlowVersionForceDeleteRequestError);
+    return failure as FlowVersionForceDeleteRequestError;
+  };
+
+  it('uses native HTTP 201 and exact token-only wire body without logging or mutating shared state', async () => {
+    const f = await setup([{ statusCode: 201, body: JSON.stringify({ deleted: true, abandonedInterviewCount: 3 }) }]);
+    const result = await f.adapter.executeToken(token);
+    expect(result).to.deep.equal({ deleted: true, abandonedInterviewCount: 3 });
+    expect(f.request.calledOnce).to.equal(true);
+    const native = f.request.firstCall.args[0] as NativeRequest;
+    expect(native.method).to.equal('POST');
+    expect(native.url).to.equal(
+      'https://flow-c6-unit-test.invalid/services/data/v67.0/connect/interaction/flow-versions/force-delete'
+    );
+    expect(JSON.parse(native.body ?? '') as object).to.deep.equal({ contractVersion: '1', confirmationToken: token });
+    expect(native.headers?.Authorization).to.equal('Bearer unit-only-not-a-credential');
+    expect(native.headers?.['user-agent']).to.include('sfdx toolbelt');
+    expect(native.headers?.['content-type']).to.equal('application/json');
+    const options = f.request.firstCall.args[1] as { retry: unknown; followRedirect: boolean };
+    expect(options.retry).to.deep.equal({ methods: [], maxRetries: 0 });
+    expect(options.followRedirect).to.equal(false);
+    expect(f.debug.called).to.equal(false);
+    expect((f.connection as unknown as { logger: LoggerShape }).logger).to.equal(f.originalLogger);
+    // eslint-disable-next-line no-underscore-dangle
+    expect(f.connection._transport).to.equal(f.originalTransport);
+    // eslint-disable-next-line no-underscore-dangle
+    expect((f.connection as unknown as { _logLevel: string })._logLevel).to.equal('DEBUG');
+  });
+
+  it('keeps preview response tokens out of raw SDK logging too', async () => {
+    const f = await setup([{ statusCode: 201, body: JSON.stringify({ eligible: true, confirmationToken: token }) }]);
+    const response = await f.adapter.previewVersion({
+      versionId: '301000000000001AAA',
+      expectedDefinitionId: '300000000000001AAA',
+    });
+    expect(response).to.deep.equal({ eligible: true, confirmationToken: token });
+    expect(f.debug.called).to.equal(false);
+    const body = JSON.parse((f.request.firstCall.args[0] as NativeRequest).body ?? '') as object;
+    expect(body).to.deep.equal({
+      contractVersion: '1',
+      versionId: '301000000000001AAA',
+      expectedDefinitionId: '300000000000001AAA',
+    });
+  });
+
+  it('does not expose a token echoed by native HTTP 400 in message, stack, cause or serialized error', async () => {
+    const f = await setup([{ statusCode: 400, body: JSON.stringify([{ errorCode: 'BAD_REQUEST', message: token }]) }]);
+    const error = await caught(f.adapter.executeToken(token));
+    expect(error.statusCode).to.equal(400);
+    expect(error.outcomeConfirmed).to.equal(true);
+    expect(error.requestSent).to.equal(true);
+    expect(error.message).not.to.include(token);
+    expect(error.stack).not.to.include(token);
+    expect(JSON.stringify(error)).not.to.include(token);
+    expect(Object.hasOwn(error, 'cause')).to.equal(false);
+    expect(f.debug.called).to.equal(false);
+    expect(f.request.calledOnce).to.equal(true);
+  });
+
+  for (const statusCode of [408, 429, 503]) {
+    it(`keeps native HTTP ${statusCode} uncertain and does not retry the mutation`, async () => {
+      const f = await setup([{ statusCode, body: JSON.stringify([{ errorCode: 'BAD_REQUEST', message: token }]) }]);
+      const error = await caught(f.adapter.executeToken(token));
+      expect(error.outcomeConfirmed).to.equal(false);
+      expect(error.statusCode).to.equal(statusCode);
+      expect(error.message).not.to.include(token);
+      expect(f.request.calledOnce).to.equal(true);
+    });
+  }
+
+  it('preserves native 401 refresh, original authenticated state and final acknowledgement', async () => {
+    const f = await setup([
+      { statusCode: 401, body: JSON.stringify([{ errorCode: 'INVALID_SESSION_ID', message: 'Expired.' }]) },
+      { statusCode: 201, body: JSON.stringify({ deleted: true, abandonedInterviewCount: 3 }) },
+    ]);
+    const refresh = sandbox.stub().callsFake(async (): Promise<void> => {
+      f.connection.accessToken = 'unit-only-refreshed-token';
+    });
+    Object.assign(f.connection, {
+      _refreshDelegate: { isRefreshing: () => false, refresh, waitRefresh: async () => undefined },
+    });
+    await f.adapter.executeToken(token);
+    expect(refresh.calledOnce).to.equal(true);
+    expect(f.request.callCount).to.equal(2);
+    expect((f.request.secondCall.args[0] as NativeRequest).headers?.Authorization).to.equal(
+      'Bearer unit-only-refreshed-token'
+    );
+    expect(f.connection.accessToken).to.equal('unit-only-refreshed-token');
+    expect(f.debug.called).to.equal(false);
+    for (const call of f.request.getCalls())
+      expect((call.args[1] as { retry: unknown }).retry).to.deep.equal({ methods: [], maxRetries: 0 });
+  });
+
+  it('does not mistake a lost refreshed response for the preceding conclusive 401', async () => {
+    const f = await setup([
+      { statusCode: 401, body: JSON.stringify([{ errorCode: 'INVALID_SESSION_ID', message: 'Expired.' }]) },
+      new Error(`Connection lost ${token}`),
+    ]);
+    Object.assign(f.connection, {
+      _refreshDelegate: {
+        isRefreshing: () => false,
+        refresh: async () => undefined,
+        waitRefresh: async () => undefined,
+      },
+    });
+    const error = await caught(f.adapter.executeToken(token));
+    expect(error.statusCode).to.equal(null);
+    expect(error.outcomeConfirmed).to.equal(false);
+    expect(error.message).not.to.include(token);
+    expect(f.request.callCount).to.equal(2);
+    expect(f.debug.called).to.equal(false);
+  });
+
+  it('does not leak raw HTML or network messages through native logger output', async () => {
+    const log = sandbox.spy(console, 'log');
+    const warn = sandbox.spy(console, 'warn');
+    const errorLog = sandbox.spy(console, 'error');
+    const f = await setup([{ statusCode: 502, body: `<html>${token}</html>` }]);
+    const error = await caught(f.adapter.executeToken(token));
+    expect(error.outcomeConfirmed).to.equal(false);
+    for (const spy of [log, warn, errorLog, f.debug]) expect(JSON.stringify(spy.args)).not.to.include(token);
+    expect(error.message).not.to.include(token);
+  });
+
+  it('requires an observed native HTTP 201, not only a plausible acknowledgement body', async () => {
+    const f = await setup([{ statusCode: 200, body: JSON.stringify({ deleted: true, abandonedInterviewCount: 3 }) }]);
+    const error = await caught(f.adapter.executeToken(token));
+    expect(error.outcomeConfirmed).to.equal(false);
+    expect(error.statusCode).to.equal(200);
+  });
+
+  it('handles an absent native response without a detached unhandled rejection', async () => {
+    const f = await setup([undefined]);
+    const unhandled: unknown[] = [];
+    const listener = (reason: unknown): void => {
+      unhandled.push(reason);
+    };
+    process.on('unhandledRejection', listener);
+    try {
+      const error = await caught(f.adapter.executeToken(token));
+      await new Promise<void>((resolve) => setImmediate(resolve));
+      expect(error.outcomeConfirmed).to.equal(false);
+      expect(error.statusCode).to.equal(null);
+      expect(unhandled).to.deep.equal([]);
+    } finally {
+      process.off('unhandledRejection', listener);
+    }
+  });
+});
diff --git a/test/services/flowVersionDeleteC2Transport.test.ts b/test/services/flowVersionDeleteC2Transport.test.ts
new file mode 100644
index 0000000..e14c5d2
--- /dev/null
+++ b/test/services/flowVersionDeleteC2Transport.test.ts
@@ -0,0 +1,220 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { PassThrough } from 'node:stream';
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { Connection, type AuthInfo } from '@salesforce/core';
+import { ConnectToolingFlowVersionDeleteClient, FlowVersionDeleteRequestError } from '@salesforce/flow-node';
+
+const versionId = '301000000000002AAA';
+type NativeRequest = { method: string; url: string; headers?: Record<string, string> };
+type Reply = { statusCode: number; body: string } | Error | undefined;
+
+// Native HTTP parsing and refresh are exercised, with no network or org access.
+describe('C2 deletion through the installed authenticated Connection', () => {
+  const sandbox = sinon.createSandbox();
+  afterEach(() => sandbox.restore());
+
+  const setup = async (replies: Reply[]) => {
+    const connection = new Connection({
+      authInfo: {
+        getUsername: () => 'c2-unit-only@example.invalid',
+        getFields: () => ({ orgId: '00D000000000001EAA' }),
+      } as AuthInfo,
+      connectionOptions: {
+        instanceUrl: 'https://flow-c2-unit-test.invalid',
+        accessToken: 'unit-test-only-not-a-credential',
+        version: '67.0',
+      },
+    });
+    await connection.init();
+    // eslint-disable-next-line no-underscore-dangle
+    const originalTransport = connection._transport;
+    const request = sandbox.stub(originalTransport, 'httpRequest').callsFake(() => {
+      if (replies.length === 0) throw new Error('Unexpected native HTTP request');
+      const reply = replies.shift();
+      const promise =
+        reply instanceof Error
+          ? Promise.reject(reply)
+          : Promise.resolve(
+              reply === undefined
+                ? undefined
+                : {
+                    statusCode: reply.statusCode,
+                    body: reply.body,
+                    headers: { 'content-type': 'application/json' },
+                  }
+            );
+      // Deliberately permit a missing native response to verify the protocol failure path.
+      return Object.assign(promise, { stream: () => new PassThrough() }) as unknown as ReturnType<
+        typeof originalTransport.httpRequest
+      >;
+    });
+    return { connection, originalTransport, request, adapter: new ConnectToolingFlowVersionDeleteClient(connection) };
+  };
+
+  const caughtDelete = async (
+    adapter: ConnectToolingFlowVersionDeleteClient
+  ): Promise<FlowVersionDeleteRequestError> => {
+    let caught: unknown;
+    try {
+      await adapter.deleteVersion(versionId);
+    } catch (error) {
+      caught = error;
+    }
+    expect(caught).to.be.instanceOf(FlowVersionDeleteRequestError);
+    return caught as FlowVersionDeleteRequestError;
+  };
+
+  it('accepts native HTTP 204 without replacing the shared transport', async () => {
+    const { connection, adapter, request, originalTransport } = await setup([{ statusCode: 204, body: '' }]);
+    await adapter.deleteVersion(versionId);
+
+    expect(request.calledOnce).to.equal(true);
+    const native = request.firstCall.args[0] as NativeRequest;
+    expect(native.method).to.equal('DELETE');
+    expect(native.url).to.equal(
+      `https://flow-c2-unit-test.invalid/services/data/v67.0/tooling/sobjects/Flow/${versionId}`
+    );
+    expect(native.headers?.Authorization).to.equal('Bearer unit-test-only-not-a-credential');
+    const options = request.firstCall.args[1] as {
+      followRedirect: boolean;
+      retry: { methods: string[]; maxRetries: number };
+      transport: unknown;
+    };
+    expect(options.followRedirect).to.equal(false);
+    expect(options.retry).to.deep.equal({ methods: [], maxRetries: 0 });
+    expect(options.transport).not.to.equal(originalTransport);
+    // eslint-disable-next-line no-underscore-dangle
+    expect(connection._transport).to.equal(originalTransport);
+  });
+
+  it('retains a conclusive native HTTP 400 rejection after the SDK drops the status', async () => {
+    const { adapter, request } = await setup([
+      {
+        statusCode: 400,
+        body: JSON.stringify([{ errorCode: 'DELETE_FAILED', message: 'The platform rejected this exact version.' }]),
+      },
+    ]);
+    const error = await caughtDelete(adapter);
+
+    expect(error.code).to.equal('DELETE_FAILED');
+    expect(error.message).to.equal('The platform rejected this exact version.');
+    expect(error.statusCode).to.equal(400);
+    expect(error.outcomeConfirmed).to.equal(true);
+    expect(error.requestSent).to.equal(true);
+    expect(request.calledOnce).to.equal(true);
+  });
+
+  it('keeps a native HTTP 503 uncertain even when its code looks like a normal veto', async () => {
+    const { adapter, request } = await setup([
+      {
+        statusCode: 503,
+        body: JSON.stringify([{ errorCode: 'DELETE_FAILED', message: 'The server could not establish the outcome.' }]),
+      },
+    ]);
+    const error = await caughtDelete(adapter);
+
+    expect(error.code).to.equal('DELETE_FAILED');
+    expect(error.statusCode).to.equal(503);
+    expect(error.outcomeConfirmed).to.equal(false);
+    expect(request.calledOnce).to.equal(true);
+  });
+
+  it('reports a missing native response as uncertain without a detached unhandled rejection', async () => {
+    const { adapter, request } = await setup([undefined]);
+    const unhandled: unknown[] = [];
+    const listener = (reason: unknown): void => {
+      unhandled.push(reason);
+    };
+    process.on('unhandledRejection', listener);
+    try {
+      const error = await caughtDelete(adapter);
+      await new Promise<void>((resolve) => setImmediate(resolve));
+
+      expect(error.code).to.equal('UNKNOWN_DELETE_OUTCOME');
+      expect(error.outcomeConfirmed).to.equal(false);
+      expect(error.statusCode).to.equal(null);
+      expect(error.requestSent).to.equal(true);
+      expect(request.calledOnce).to.equal(true);
+      expect(unhandled).to.deep.equal([]);
+    } finally {
+      process.off('unhandledRejection', listener);
+    }
+  });
+
+  it('preserves native session refresh and the final HTTP 204 acknowledgement', async () => {
+    const { connection, adapter, request, originalTransport } = await setup([
+      { statusCode: 401, body: JSON.stringify([{ errorCode: 'INVALID_SESSION_ID', message: 'Session expired.' }]) },
+      { statusCode: 204, body: '' },
+    ]);
+    const refresh = sandbox.stub().resolves();
+    Object.assign(connection, {
+      _refreshDelegate: { isRefreshing: () => false, refresh, waitRefresh: async () => undefined },
+    });
+
+    await adapter.deleteVersion(versionId);
+
+    expect(refresh.calledOnce).to.equal(true);
+    expect(request.callCount).to.equal(2);
+    // eslint-disable-next-line no-underscore-dangle
+    expect(connection._transport).to.equal(originalTransport);
+    for (const call of request.getCalls()) {
+      expect((call.args[0] as NativeRequest).method).to.equal('DELETE');
+      expect((call.args[1] as { retry: unknown }).retry).to.deep.equal({ methods: [], maxRetries: 0 });
+    }
+  });
+
+  it('does not reuse a stale 401 status when the refreshed DELETE loses its response', async () => {
+    const { connection, adapter, request } = await setup([
+      { statusCode: 401, body: JSON.stringify([{ errorCode: 'INVALID_SESSION_ID', message: 'Session expired.' }]) },
+      new Error('Connection closed before the response arrived.'),
+    ]);
+    const refresh = sandbox.stub().resolves();
+    Object.assign(connection, {
+      _refreshDelegate: { isRefreshing: () => false, refresh, waitRefresh: async () => undefined },
+    });
+
+    const error = await caughtDelete(adapter);
+
+    expect(refresh.calledOnce).to.equal(true);
+    expect(request.callCount).to.equal(2);
+    expect(error.outcomeConfirmed).to.equal(false);
+    expect(error.statusCode).to.equal(null);
+    expect(error.requestSent).to.equal(true);
+  });
+
+  for (const statusCode of [408, 429]) {
+    it(`does not certify a native HTTP ${statusCode} response as a failed deletion`, async () => {
+      const { adapter, request } = await setup([
+        { statusCode, body: JSON.stringify([{ errorCode: 'DELETE_FAILED', message: 'Request was interrupted.' }]) },
+      ]);
+      const error = await caughtDelete(adapter);
+      expect(error.outcomeConfirmed).to.equal(false);
+      expect(error.statusCode).to.equal(statusCode);
+      expect(request.calledOnce).to.equal(true);
+    });
+  }
+
+  it('does not expose HTML or credential-like native error messages', async () => {
+    const { adapter } = await setup([{ statusCode: 502, body: '<html>Authorization Bearer private-value</html>' }]);
+    const error = await caughtDelete(adapter);
+    expect(error.message).not.to.include('private-value');
+    expect(error.message).not.to.include('<html>');
+    expect(error.outcomeConfirmed).to.equal(false);
+  });
+});
diff --git a/test/services/flowVersionListTransport.test.ts b/test/services/flowVersionListTransport.test.ts
new file mode 100644
index 0000000..cbce5ff
--- /dev/null
+++ b/test/services/flowVersionListTransport.test.ts
@@ -0,0 +1,479 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { PassThrough } from 'node:stream';
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { Connection, type AuthInfo } from '@salesforce/core';
+import { FlowVersionError, FlowVersionListService, ToolingFlowVersionListClient } from '@salesforce/flow-node';
+
+const versionId = (number: number): string => `301${String(number).padStart(12, '0')}AAA`;
+const record = (number: number): Record<string, unknown> => ({
+  Id: versionId(number),
+  DefinitionId: '300000000000001AAA',
+  Definition: { DeveloperName: 'Invoice_Approval', NamespacePrefix: null },
+  MasterLabel: 'Invoice Approval - Review',
+  VersionNumber: number,
+  Status: number === 1 ? 'Active' : 'Draft',
+  CreatedDate: '2026-01-01T00:00:00.000+0000',
+  CreatedById: '005000000000001AAA',
+  CreatedBy: { Name: 'Fixture Creator' },
+  LastModifiedDate: '2026-01-02T00:00:00.000+0000',
+});
+type NativeRequest = { method: string; url: string; body?: unknown; headers?: Record<string, string> };
+const capturedRequest = (call: sinon.SinonSpyCall): NativeRequest => call.args[0] as NativeRequest;
+const assessmentPath = '/services/data/v67.0/connect/interaction/flow-versions/deletion-assessment';
+const requestBody = (request: NativeRequest): string => {
+  if (request.body === undefined || request.body === null) return '{}';
+  if (typeof request.body !== 'string') throw new TypeError('Expected a serialized JSON request body.');
+  return request.body;
+};
+const incomingInterview = {
+  sourceId: '0Fo000000000001',
+  sourceType: 'FlowInterview',
+  sourceName: '00000003',
+  targetKind: 'VERSION',
+  targetId: versionId(2).slice(0, 15),
+  targetName: null,
+  channels: ['EXTERNALIZED_REFERENCE'],
+  interviewRoles: ['PERSISTED_REFERENCE'],
+  detailsRedacted: false,
+};
+
+describe('Flow version listing through the installed authenticated Connection', () => {
+  const sandbox = sinon.createSandbox();
+  afterEach(() => sandbox.restore());
+
+  const connectionWithResponses = async (
+    responses: Array<{ statusCode: number; body: unknown }>,
+    facts: {
+      assessments?: Record<string, Record<string, unknown>>;
+      assessmentFailure?: { statusCode: number; body: unknown };
+      omitCounts?: boolean;
+      omitVersionLimit?: boolean;
+      versionLimit?: number;
+    } = {}
+  ): Promise<{ connection: Connection; request: sinon.SinonStub }> => {
+    const connection = new Connection({
+      authInfo: {
+        getUsername: () => 'unit-test-only@example.invalid',
+        getFields: () => ({ orgId: '00D000000000001EAA' }),
+      } as AuthInfo,
+      connectionOptions: {
+        instanceUrl: 'https://flow-list-unit-test.invalid',
+        accessToken: 'unit-test-only-not-a-credential',
+        version: '67.0',
+      },
+    });
+    await connection.init();
+    // Mock below native parsing/authentication. No request reaches a real org.
+    // eslint-disable-next-line no-underscore-dangle
+    const request = sandbox.stub(connection._transport, 'httpRequest').callsFake((httpRequest: NativeRequest) => {
+      const url = new URL(httpRequest.url);
+      let response: { statusCode: number; body: unknown } | undefined;
+      if (url.pathname === assessmentPath) {
+        const body = JSON.parse(requestBody(httpRequest)) as { targets: Array<{ versionId: string }> };
+        response = facts.assessmentFailure ?? {
+          statusCode: 201,
+          body: {
+            contractVersion: '1',
+            results: body.targets.map((target) => ({
+              versionId: target.versionId.slice(0, 15),
+              outcome: 'PASS',
+              reasonCode: null,
+              message: null,
+              evidence: [],
+              ...(facts.omitCounts
+                ? {}
+                : { counts: { referenceCount: 0, pausedInterviewCount: 0, failedInterviewCount: 0 } }),
+              ...(facts.omitVersionLimit ? {} : { versionLimit: facts.versionLimit ?? 25 }),
+              ...(facts.assessments?.[target.versionId.slice(0, 15)] ?? {}),
+            })),
+          },
+        };
+      } else {
+        response = responses.shift();
+      }
+      if (!response) throw new Error('Unexpected additional HTTP request');
+      return Object.assign(
+        Promise.resolve({
+          statusCode: response.statusCode,
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify(response.body),
+        }),
+        { stream: () => new PassThrough() }
+      );
+    });
+    return { connection, request };
+  };
+
+  const assessmentCalls = (request: sinon.SinonStub): NativeRequest[] =>
+    request
+      .getCalls()
+      .map(capturedRequest)
+      .filter((call) => new URL(call.url).pathname === assessmentPath);
+
+  const expectOnlyReadAndAssessmentRequests = (request: sinon.SinonStub): void => {
+    for (const call of request.getCalls()) {
+      const input = capturedRequest(call);
+      expect(['GET', 'POST']).to.include(input.method);
+      if (input.method === 'POST') expect(new URL(input.url).pathname).to.equal(assessmentPath);
+      expect(JSON.stringify(input.headers ?? {}).toLowerCase()).not.to.include('uitier');
+      expect(JSON.stringify(input.headers ?? {}).toLowerCase()).not.to.include('lightning');
+      expect(new URL(input.url).pathname).not.to.include('/describe');
+      const query = new URL(input.url).searchParams.get('q') ?? '';
+      for (const obsoleteRead of ['FlowInterview', 'MetadataComponentDependency', 'ManageableState'])
+        expect(query).not.to.include(obsoleteRead);
+    }
+  };
+
+  it('pages native inventory, then accepts HTTP 201 and canonicalizes the backend 15-character result', async () => {
+    const { connection, request } = await connectionWithResponses([
+      {
+        statusCode: 200,
+        body: {
+          totalSize: 2,
+          done: false,
+          nextRecordsUrl: '/services/data/v67.0/tooling/query/01g000000000001AAA',
+          records: [record(1)],
+        },
+      },
+      { statusCode: 200, body: { totalSize: 2, done: true, records: [record(2)] } },
+    ]);
+    const report = await new FlowVersionListService(
+      new ToolingFlowVersionListClient(connection),
+      () => new Date('2026-10-27T00:00:00.000Z')
+    ).list({ all: true, status: 'inactive' });
+    expect(report).to.include({ contractVersion: '6', totalVersions: 2, matchedVersions: 1 });
+    expect(report.rows[0]).to.include({
+      versionNumber: 2,
+      versionCount: 2,
+      versionLimit: 25,
+      percentUsed: 8,
+      createdByName: 'Fixture Creator',
+      versionName: 'Invoice Approval - Review',
+    });
+    expect(report.rows[0].c1Counts).to.deep.equal({
+      referenceCount: 0,
+      pausedInterviewCount: 0,
+      failedInterviewCount: 0,
+    });
+    expect(report.rows[0].assessment).to.deep.equal({
+      versionId: versionId(2),
+      outcome: 'PASS',
+      reasonCode: null,
+      message: null,
+      evidence: [],
+      counts: { referenceCount: 0, pausedInterviewCount: 0, failedInterviewCount: 0 },
+      versionLimit: 25,
+    });
+    expect(report.assessmentCounts).to.deep.equal({ pass: 1, blocked: 0, error: 0 });
+    expect(report.assessmentErrors).to.deep.equal([]);
+    expect(report.countErrors).to.deep.equal([]);
+    expect(report.capacityErrors).to.deep.equal([]);
+    expect(report.warnings).to.deep.equal([]);
+    const posts = assessmentCalls(request);
+    expect(posts).to.have.length(1);
+    expect(JSON.parse(requestBody(posts[0]))).to.deep.equal({
+      contractVersion: '1',
+      targets: [{ versionId: versionId(2), expectedDefinitionId: '300000000000001AAA' }],
+    });
+    const inventory = request
+      .getCalls()
+      .map(capturedRequest)
+      .find((call) => new URL(call.url).searchParams.get('q')?.includes('CreatedBy.Name'));
+    expect(inventory).not.to.equal(undefined);
+    expect(inventory?.url).not.to.include('Metadata');
+    expect(new URL(inventory?.url ?? '').searchParams.get('q')).to.include('MasterLabel');
+    expectOnlyReadAndAssessmentRequests(request);
+  });
+
+  it('uses complete structured backend counts without inferring totals from the blocker message or evidence', async () => {
+    const message = 'PAUSED_INTERVIEWS (2); REFERENCED_BY_VERSION (ParentFlow, OtherFlow)';
+    const { connection, request } = await connectionWithResponses(
+      [{ statusCode: 200, body: { totalSize: 2, done: true, records: [record(1), record(2)] } }],
+      {
+        assessments: {
+          [versionId(2).slice(0, 15)]: {
+            outcome: 'BLOCKED',
+            reasonCode: 'PAUSED_INTERVIEWS',
+            message,
+            evidence: [incomingInterview],
+            counts: { referenceCount: 5, pausedInterviewCount: 2, failedInterviewCount: 3 },
+          },
+        },
+      }
+    );
+    const report = await new FlowVersionListService(new ToolingFlowVersionListClient(connection)).list({ all: true });
+    const draft = report.rows.find((row) => row.versionNumber === 2);
+    expect(draft?.c1Counts).to.deep.equal({ referenceCount: 5, pausedInterviewCount: 2, failedInterviewCount: 3 });
+    expect(draft?.assessment).to.include({ outcome: 'BLOCKED', reasonCode: 'PAUSED_INTERVIEWS', message });
+    expect(draft?.assessment.evidence[0]).to.include({
+      sourceId: '0Fo000000000001CAA',
+      targetId: versionId(2),
+      targetName: null,
+    });
+    expect(draft?.assessment.evidence[0].interviewRoles).to.deep.equal(['PERSISTED_REFERENCE']);
+    expectOnlyReadAndAssessmentRequests(request);
+  });
+
+  it('retains one per-item ERROR while --deletable still returns the other backend PASS result', async () => {
+    const { connection, request } = await connectionWithResponses(
+      [{ statusCode: 200, body: { totalSize: 2, done: true, records: [record(1), record(2)] } }],
+      {
+        assessments: {
+          [versionId(1).slice(0, 15)]: {
+            outcome: 'ERROR',
+            reasonCode: 'OWNED_RESOURCE_CHECK_INCOMPLETE',
+            message: null,
+            evidence: [],
+          },
+        },
+      }
+    );
+    const report = await new FlowVersionListService(new ToolingFlowVersionListClient(connection)).list({
+      all: true,
+      deletable: true,
+    });
+    expect(report.rows).to.have.length(1);
+    expect(report.rows[0].versionNumber).to.equal(2);
+    expect(report.rows[0].assessment.outcome).to.equal('PASS');
+    expect(report.assessmentErrors).to.have.length(1);
+    expect(report.assessmentErrors[0].versionNumber).to.equal(1);
+    expect(report.assessmentErrors[0].assessment).to.include({
+      outcome: 'ERROR',
+      reasonCode: 'OWNED_RESOURCE_CHECK_INCOMPLETE',
+      message: null,
+    });
+    expect(report.assessmentCounts).to.deep.equal({ pass: 1, blocked: 0, error: 1 });
+    expect(report.assessmentErrors[0].c1Counts).to.equal(null);
+    expect(report.assessmentErrors[0].countError).to.equal(null);
+    expect(report.countErrors).to.deep.equal([]);
+    expectOnlyReadAndAssessmentRequests(request);
+  });
+
+  it('does not override backend PASS with local status, last-version or count rules', async () => {
+    const { connection, request } = await connectionWithResponses(
+      [{ statusCode: 200, body: { totalSize: 1, done: true, records: [record(1)] } }],
+      {
+        assessments: {
+          [versionId(1).slice(0, 15)]: {
+            counts: { referenceCount: 3, pausedInterviewCount: 9, failedInterviewCount: 2 },
+          },
+        },
+      }
+    );
+    const report = await new FlowVersionListService(new ToolingFlowVersionListClient(connection)).list({
+      all: true,
+      deletable: true,
+    });
+    expect(report.rows).to.have.length(1);
+    expect(report.rows[0]).to.include({
+      status: 'Active',
+      versionCount: 1,
+    });
+    expect(report.rows[0].c1Counts).to.deep.equal({
+      referenceCount: 3,
+      pausedInterviewCount: 9,
+      failedInterviewCount: 2,
+    });
+    expect(report.rows[0].assessment.outcome).to.equal('PASS');
+    expect(report.rows[0]).not.to.have.property('blockingReasons');
+    expect(report.rows[0]).not.to.have.property('deletability');
+    expectOnlyReadAndAssessmentRequests(request);
+  });
+
+  it('retains missing C1 counts as a report error instead of inventing zero or counting evidence', async () => {
+    const { connection, request } = await connectionWithResponses(
+      [{ statusCode: 200, body: { totalSize: 1, done: true, records: [record(2)] } }],
+      { omitCounts: true }
+    );
+    const report = await new FlowVersionListService(new ToolingFlowVersionListClient(connection)).list({ all: true });
+    expect(report.rows[0].assessment.outcome).to.equal('PASS');
+    expect(report.rows[0].c1Counts).to.equal(null);
+    expect(report.rows[0].countError?.code).to.equal('C1_COUNTS_UNAVAILABLE');
+    expect(report.countErrors).to.have.length(1);
+    expect(report.rows[0]).not.to.have.property('referenceCount');
+    expect(report.rows[0]).not.to.have.property('pausedInterviewCount');
+    expectOnlyReadAndAssessmentRequests(request);
+  });
+
+  it('uses the backend configured limit rather than a fixed denominator for the utilization filter', async () => {
+    await Promise.all(
+      [25, 100].map(async (limit) => {
+        const { connection, request } = await connectionWithResponses(
+          [{ statusCode: 200, body: { totalSize: 2, done: true, records: [record(1), record(2)] } }],
+          { versionLimit: limit }
+        );
+        const report = await new FlowVersionListService(new ToolingFlowVersionListClient(connection)).list({
+          all: true,
+          minPercent: 5,
+        });
+        expect(report.rows).to.have.length(limit === 25 ? 2 : 0);
+        for (const row of report.rows) {
+          expect(row.versionLimit).to.equal(limit);
+          expect(row.percentUsed).to.equal(8);
+        }
+        expect(report.capacityErrors).to.deep.equal([]);
+        expect(assessmentCalls(request)).to.have.length(1);
+        expectOnlyReadAndAssessmentRequests(request);
+      })
+    );
+  });
+
+  it('retains unavailable configured limits as errors instead of treating them as matching a usage filter', async () => {
+    const { connection, request } = await connectionWithResponses(
+      [{ statusCode: 200, body: { totalSize: 1, done: true, records: [record(2)] } }],
+      { omitVersionLimit: true }
+    );
+    const report = await new FlowVersionListService(new ToolingFlowVersionListClient(connection)).list({
+      all: true,
+      minPercent: 80,
+    });
+    expect(report.rows).to.have.length(0);
+    expect(report.capacityErrors).to.have.length(1);
+    expect(report.capacityErrors[0]).to.include({ versionLimit: null, percentUsed: null });
+    expect(report.capacityErrors[0].capacityError?.code).to.equal('VERSION_LIMIT_UNAVAILABLE');
+    expect(report.capacityErrors[0].assessment.outcome).to.equal('PASS');
+    expectOnlyReadAndAssessmentRequests(request);
+  });
+
+  it('preserves a new server reason and future evidence channel without adding a CLI product branch', async () => {
+    const { connection, request } = await connectionWithResponses(
+      [{ statusCode: 200, body: { totalSize: 1, done: true, records: [record(2)] } }],
+      {
+        assessments: {
+          [versionId(2).slice(0, 15)]: {
+            outcome: 'BLOCKED',
+            reasonCode: 'FUTURE_SERVER_RULE',
+            message: 'A new backend reason; keep this exact text.',
+            evidence: [{ ...incomingInterview, channels: ['ACTIVE_VERSION', 'FUTURE_CHANNEL'] }],
+          },
+        },
+      }
+    );
+    const report = await new FlowVersionListService(new ToolingFlowVersionListClient(connection)).list({ all: true });
+    expect(report.rows[0].assessment).to.include({
+      reasonCode: 'FUTURE_SERVER_RULE',
+      message: 'A new backend reason; keep this exact text.',
+    });
+    expect(report.rows[0].assessment.evidence[0].channels).to.deep.equal(['ACTIVE_VERSION', 'FUTURE_CHANNEL']);
+    expectOnlyReadAndAssessmentRequests(request);
+  });
+
+  it('submits 101 targets as bounded independent batches with no identity, bypass or UI headers', async () => {
+    const records = Array.from({ length: 101 }, (_, index) => record(index + 1));
+    const { connection, request } = await connectionWithResponses([
+      { statusCode: 200, body: { totalSize: 101, done: true, records } },
+    ]);
+    const report = await new FlowVersionListService(new ToolingFlowVersionListClient(connection)).list({ all: true });
+    expect(report.rows).to.have.length(101);
+    expect(report.assessmentCounts.pass).to.equal(101);
+    const posts = assessmentCalls(request);
+    expect(posts.map((call) => (JSON.parse(requestBody(call)) as { targets: unknown[] }).targets.length)).to.deep.equal(
+      [100, 1]
+    );
+    for (const call of posts) {
+      const body = JSON.parse(requestBody(call)) as {
+        contractVersion: string;
+        targets: Array<Record<string, unknown>>;
+      };
+      expect(Object.keys(body).sort()).to.deep.equal(['contractVersion', 'targets']);
+      expect(body.contractVersion).to.equal('1');
+      for (const target of body.targets)
+        expect(Object.keys(target).sort()).to.deep.equal(['expectedDefinitionId', 'versionId']);
+    }
+    expectOnlyReadAndAssessmentRequests(request);
+  });
+
+  it('propagates a native HTTP 400 assessment rejection without a positive fallback or DELETE', async () => {
+    const { connection, request } = await connectionWithResponses(
+      [{ statusCode: 200, body: { totalSize: 1, done: true, records: [record(2)] } }],
+      {
+        assessmentFailure: {
+          statusCode: 400,
+          body: [{ errorCode: 'BAD_REQUEST', message: 'contractVersion must be "1"' }],
+        },
+      }
+    );
+    let caught: unknown;
+    try {
+      await new FlowVersionListService(new ToolingFlowVersionListClient(connection)).list({ all: true });
+    } catch (error) {
+      caught = error;
+    }
+    expect(caught).to.be.instanceOf(Error);
+    expect(caught).to.have.property('code', 'BAD_REQUEST');
+    expect((caught as Error).message).to.include('contractVersion must be "1"');
+    expect(assessmentCalls(request)).to.have.length(1);
+    expectOnlyReadAndAssessmentRequests(request);
+  });
+
+  it('returns a safe typed inventory permission error before submitting any assessment', async () => {
+    const { connection, request } = await connectionWithResponses([
+      {
+        statusCode: 403,
+        body: [{ errorCode: 'INSUFFICIENT_ACCESS_OR_READONLY', message: 'Fixture denies Flow access.' }],
+      },
+    ]);
+    let caught: unknown;
+    try {
+      await new FlowVersionListService(new ToolingFlowVersionListClient(connection)).list({ all: true });
+    } catch (error) {
+      caught = error;
+    }
+    expect(caught).to.be.instanceOf(FlowVersionError);
+    expect((caught as FlowVersionError).code).to.equal('INVENTORY_REQUEST_FAILED');
+    expect((caught as Error).message).to.include('INSUFFICIENT_ACCESS_OR_READONLY');
+    expect((caught as Error).message).not.to.include('Fixture denies Flow access');
+    expect(assessmentCalls(request)).to.have.length(0);
+  });
+
+  it('propagates an HTTP 503 assessment failure instead of manufacturing per-item outcomes or retrying', async () => {
+    const { connection, request } = await connectionWithResponses(
+      [{ statusCode: 200, body: { totalSize: 1, done: true, records: [record(2)] } }],
+      {
+        assessmentFailure: {
+          statusCode: 503,
+          body: [{ errorCode: 'SERVER_UNAVAILABLE', message: 'Assessment service temporarily unavailable.' }],
+        },
+      }
+    );
+    let caught: unknown;
+    try {
+      await new FlowVersionListService(new ToolingFlowVersionListClient(connection)).list({ all: true });
+    } catch (error) {
+      caught = error;
+    }
+    expect(caught).to.be.instanceOf(Error);
+    expect(assessmentCalls(request)).to.have.length(1);
+    expectOnlyReadAndAssessmentRequests(request);
+  });
+
+  it('rejects an unsafe selector before native HTTP', async () => {
+    const { connection, request } = await connectionWithResponses([]);
+    let caught: unknown;
+    try {
+      await new FlowVersionListService(new ToolingFlowVersionListClient(connection)).list({
+        flowName: "Invoice' OR Id != null",
+      });
+    } catch (error) {
+      caught = error;
+    }
+    expect(caught).to.be.instanceOf(Error);
+    expect(request.called).to.equal(false);
+  });
+});
diff --git a/test/services/flowVersionRetention.test.ts b/test/services/flowVersionRetention.test.ts
new file mode 100644
index 0000000..d7f7552
--- /dev/null
+++ b/test/services/flowVersionRetention.test.ts
@@ -0,0 +1,406 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { expect } from 'chai';
+import sinon from 'sinon';
+import {
+  FlowVersionDeleteRequestError,
+  FlowVersionDeleteService,
+  type ConnectFlowVersionListReport,
+  type ConnectFlowVersionListVersion,
+  type FlowVersionAssessmentTarget,
+} from '@salesforce/flow-node';
+import {
+  classifyRetentionFlow,
+  FlowVersionRetentionService,
+  retentionPolicy,
+} from '../../src/services/flowVersionRetention.js';
+
+const checksum = (base: string): string =>
+  base +
+  [0, 5, 10]
+    .map(
+      (start) =>
+        'ABCDEFGHIJKLMNOPQRSTUVWXYZ012345'[
+          [...base.slice(start, start + 5)].reduce((mask, char, bit) => mask | (/[A-Z]/.test(char) ? 1 << bit : 0), 0)
+        ]
+    )
+    .join('');
+const orgId = checksum('00D000000000001');
+const definitionId = checksum('300000000000001');
+const row = (n: number, extra: Partial<ConnectFlowVersionListVersion> = {}): ConnectFlowVersionListVersion => ({
+  versionId: checksum(`301${String(n).padStart(12, '0')}`),
+  versionNumber: n,
+  versionName: null,
+  status: 'Draft',
+  createdDate: '2026-01-01T00:00:00Z',
+  ageDays: 299,
+  createdById: null,
+  createdByName: null,
+  lastModifiedDate: '2026-10-20T00:00:00Z',
+  statusChangeDate: null,
+  referenceCount: 0,
+  pausedInterviewCount: 0,
+  failedInterviewCount: 0,
+  deletable: true,
+  outcome: 'PASS',
+  reasonCode: null,
+  message: null,
+  ...extra,
+});
+const report = (versions: ConnectFlowVersionListVersion[]): ConnectFlowVersionListReport => ({
+  contractVersion: '1',
+  orgId,
+  generatedAt: '2026-10-27T00:00:00Z',
+  scope: { all: false, flowName: 'billing__Invoice', namespace: null, allNamespaces: true },
+  filters: { status: null, olderThan: null, minPercent: null, deletable: false },
+  versionLimit: 50,
+  returnedVersionCount: versions.length,
+  candidateVersionCount: versions.length,
+  listTruncated: false,
+  catalogComplete: true,
+  nextOffset: null,
+  flows: [
+    {
+      definitionId,
+      apiName: 'billing__Invoice',
+      label: 'Invoice',
+      versionCount: versions.length,
+      limitPercent: versions.length * 2,
+      versions,
+    },
+  ],
+});
+const policy = { keepLatest: 1, olderThanDays: 90 };
+const classify = (versions: ConnectFlowVersionListVersion[]): ReturnType<typeof classifyRetentionFlow> =>
+  classifyRetentionFlow(report(versions).flows[0], policy);
+const reject = async (operation: Promise<unknown>, code: string): Promise<void> => {
+  let caught: unknown;
+  try {
+    await operation;
+  } catch (error) {
+    caught = error;
+  }
+  expect(caught).to.have.property('code', code);
+};
+
+describe('C4 retention policy', () => {
+  it('protects Active, latest N, and newest Obsolete statusChangeDate before age/eligibility filtering', () => {
+    const result = classify([
+      row(1, { status: 'Active' }),
+      row(2, { status: 'Obsolete', statusChangeDate: '2026-03-01T12:00:00Z' }),
+      row(3, {
+        status: 'Obsolete',
+        statusChangeDate: '2026-02-01T12:00:00Z',
+        lastModifiedDate: '2026-10-27T12:00:00Z',
+      }),
+      row(4),
+      row(7),
+    ]);
+    expect(result.versions.map((item) => item.disposition)).to.deep.equal([
+      'KEPT',
+      'KEPT',
+      'CANDIDATE',
+      'CANDIDATE',
+      'KEPT',
+    ]);
+    expect(result.versions[1].reasons[0].code).to.equal('PREVIOUSLY_ACTIVE');
+  });
+
+  it('never lets a null timestamp beat a stored time', () => {
+    const result = classify([
+      row(1, { status: 'Obsolete', statusChangeDate: null }),
+      row(2, { status: 'Obsolete', statusChangeDate: '2026-03-01T12:00:00Z' }),
+      row(3),
+    ]);
+    expect(result.versions[0].disposition).to.equal('CANDIDATE');
+    expect(result.versions[1].disposition).to.equal('KEPT');
+  });
+
+  it('conservatively protects all tied newest timestamps and all Obsolete when every timestamp is null', () => {
+    const tied = classify([
+      row(1, { status: 'Obsolete', statusChangeDate: '2026-03-01T12:00:00Z' }),
+      row(2, { status: 'Obsolete', statusChangeDate: '2026-03-01T12:00:00Z' }),
+      row(3),
+    ]);
+    expect(tied.versions.slice(0, 2).map((item) => item.reasons[0].code)).to.deep.equal([
+      'ROLLBACK_TIME_TIE',
+      'ROLLBACK_TIME_TIE',
+    ]);
+    const undated = classify([row(1, { status: 'Obsolete' }), row(2, { status: 'Obsolete' }), row(3)]);
+    expect(undated.versions.slice(0, 2).map((item) => item.reasons[0].code)).to.deep.equal([
+      'ROLLBACK_TIME_UNAVAILABLE',
+      'ROLLBACK_TIME_UNAVAILABLE',
+    ]);
+  });
+
+  it('distinguishes old-server missing field from valid stored null', () => {
+    const version = row(1);
+    Reflect.deleteProperty(version, 'statusChangeDate');
+    expect(() => classify([version, row(2)])).to.throw('Rebuild and restart');
+  });
+
+  it('does not authorize a Flow when an unknown status prevents determining the protected set', () => {
+    const result = classify([row(1, { status: null }), row(2), row(3)]);
+    expect(result.versions.every((item) => item.disposition === 'ERROR')).to.equal(true);
+  });
+
+  it('retains genuine backend blockers and errors, uses inclusive server ages, and never substitutes a zero age', () => {
+    const result = classify([
+      row(1, {
+        outcome: 'BLOCKED',
+        deletable: false,
+        reasonCode: 'PAUSED_INTERVIEWS',
+        message: 'PAUSED_INTERVIEWS (2)',
+      }),
+      row(2, { outcome: 'ERROR', deletable: false, reasonCode: 'OPERATIONAL' }),
+      row(3, { ageDays: 89 }),
+      row(4, { ageDays: 90 }),
+      row(5, { ageDays: null }),
+      row(6),
+    ]);
+    expect(result.versions.map((item) => item.disposition)).to.deep.equal([
+      'BLOCKED',
+      'ERROR',
+      'KEPT',
+      'CANDIDATE',
+      'ERROR',
+      'KEPT',
+    ]);
+    expect(result.versions[0].reasons[0].message).to.equal('PAUSED_INTERVIEWS (2)');
+  });
+
+  it('keeps young rows before checking backend eligibility, while preserving actual backend error and blocker metadata', () => {
+    const result = classify([
+      row(1, {
+        ageDays: 3,
+        outcome: 'BLOCKED',
+        deletable: false,
+        reasonCode: 'PAUSED_INTERVIEWS',
+        message: 'PAUSED_INTERVIEWS (1)',
+      }),
+      row(2, { ageDays: 4, outcome: 'ERROR', deletable: false, reasonCode: 'OPERATIONAL' }),
+      row(3),
+    ]);
+    expect(result.versions.slice(0, 2).map((item) => item.disposition)).to.deep.equal(['KEPT', 'KEPT']);
+    expect(result.versions[0].message).to.equal('PAUSED_INTERVIEWS (1)');
+    expect(result.versions[1].outcome).to.equal('ERROR');
+  });
+
+  it('validates configurable retention values without inventing alternate units or zero retained versions', () => {
+    expect(retentionPolicy(5, '90d')).to.deep.equal({ keepLatest: 5, olderThanDays: 90 });
+    for (const keep of [0, -1, 1.2, Number.NaN]) expect(() => retentionPolicy(keep, '90d')).to.throw();
+    for (const age of ['90', '1h', '-1d', '1.2d', '36501d']) expect(() => retentionPolicy(5, age)).to.throw();
+  });
+});
+
+describe('C4 retention execution', () => {
+  const sandbox = sinon.createSandbox();
+  let current: ConnectFlowVersionListReport;
+  let currentOrg: string;
+  let list: sinon.SinonStub;
+  let assess: sinon.SinonStub;
+  let remove: sinon.SinonStub;
+  let service: FlowVersionRetentionService;
+
+  beforeEach(() => {
+    current = report([row(3), row(2), row(1)]);
+    currentOrg = orgId;
+    list = sandbox.stub().callsFake(() => structuredClone(current));
+    assess = sandbox.stub().callsFake((targets: FlowVersionAssessmentTarget[]) =>
+      targets.map((target) => ({
+        versionId: target.versionId,
+        outcome: 'PASS',
+        reasonCode: null,
+        message: null,
+        evidence: [],
+      }))
+    );
+    remove = sandbox.stub().callsFake((versionId: string) => {
+      const flow = current.flows[0];
+      flow.versions = flow.versions.filter((version) => version.versionId !== versionId);
+      flow.versionCount = flow.versions.length;
+      flow.limitPercent = flow.versions.length * 2;
+      current.candidateVersionCount = current.returnedVersionCount = flow.versions.length;
+    });
+    service = new FlowVersionRetentionService(
+      { list },
+      {
+        getOrgId: () => currentOrg,
+        inventory: sandbox.stub().throws('C4 does not guess namespace'),
+        assessVersions: assess,
+        deleteVersion: remove,
+      }
+    );
+  });
+  afterEach(() => sandbox.restore());
+
+  it('pages/list-merges through the C1 client before selecting, and a preview calls only unfiltered C1', async () => {
+    const plan = await service.plan({ all: true }, policy);
+    expect(list.calledOnceWithExactly({ all: true })).to.equal(true);
+    expect(plan.flows[0].versions.map((item) => item.disposition)).to.deep.equal(['KEPT', 'CANDIDATE', 'CANDIDATE']);
+    expect(assess.called || remove.called).to.equal(false);
+  });
+
+  it('snapshots the validated policy before the first asynchronous catalog read', async () => {
+    let finish: (() => void) | undefined;
+    list.callsFake(
+      () =>
+        new Promise<ConnectFlowVersionListReport>((resolve) => {
+          finish = () => resolve(structuredClone(current));
+        })
+    );
+    const supplied = { ...policy };
+    const pending = service.plan({ all: true }, supplied);
+    supplied.keepLatest = 3;
+    supplied.olderThanDays = 0;
+    finish!();
+    const plan = await pending;
+    expect(plan.policy).to.deep.equal(policy);
+    expect(plan.flows[0].versions.filter((item) => item.disposition === 'CANDIDATE')).to.have.length(2);
+  });
+
+  it('rejects incomplete catalogs and old backend metadata with no deletion', async () => {
+    current.catalogComplete = false;
+    await reject(service.plan({ all: true }, policy), 'RETENTION_CATALOG_INCOMPLETE');
+    current.catalogComplete = true;
+    Reflect.deleteProperty(current.flows[0].versions[0], 'statusChangeDate');
+    await reject(service.plan({ all: true }, policy), 'RETENTION_METADATA_UNAVAILABLE');
+    expect(remove.called).to.equal(false);
+  });
+
+  it('reuses C2 assessment and Tooling deletion for exact approved IDs, including fully qualified API names', async () => {
+    const plan = await service.plan({ flowName: 'billing__Invoice' }, policy);
+    const result = await service.execute(plan);
+    expect(result.outcome).to.equal('SUCCEEDED');
+    expect(result.results.map((item) => item.versionNumber)).to.deep.equal([1, 2]);
+    expect(remove.args).to.deep.equal([[row(1).versionId], [row(2).versionId]]);
+    expect(list.callCount).to.be.greaterThan(3);
+    expect(list.args.every(([input]) => !('status' in input) && !('deletable' in input))).to.equal(true);
+    expect(current.flows[0].versions.map((item) => item.versionNumber)).to.deep.equal([3]);
+  });
+
+  it('never retargets a replaced version number after preview', async () => {
+    const plan = await service.plan({ all: true }, policy);
+    current.flows[0].versions[2].versionId = row(10).versionId;
+    const result = await service.execute(plan);
+    expect(result.results.map((item) => item.state)).to.deep.equal(['FAILED', 'SUCCEEDED']);
+    expect(result.results[0].error?.code).to.equal('TARGET_CHANGED');
+    expect(remove.args).to.deep.equal([[row(2).versionId]]);
+  });
+
+  it('fresh retention check protects a candidate that became the rollback target after fresh PASS', async () => {
+    const plan = await service.plan({ all: true }, policy);
+    assess.callsFake((targets: FlowVersionAssessmentTarget[]) => {
+      if (targets.length === 1 && targets[0].versionId === row(1).versionId) {
+        current.flows[0].versions[2].status = 'Obsolete';
+        current.flows[0].versions[2].statusChangeDate = '2026-10-27T12:00:00Z';
+      }
+      return targets.map((target) => ({
+        versionId: target.versionId,
+        outcome: 'PASS',
+        reasonCode: null,
+        message: null,
+        evidence: [],
+      }));
+    });
+    const result = await service.execute(plan);
+    expect(result.results.map((item) => item.state)).to.deep.equal(['BLOCKED', 'SUCCEEDED']);
+    expect(result.results[0].source).to.equal('CLIENT_POLICY');
+    expect(remove.args).to.deep.equal([[row(2).versionId]]);
+  });
+
+  it('keeps fresh assessment ERROR distinct from a blocker and continues an eligible sibling', async () => {
+    const plan = await service.plan({ all: true }, policy);
+    assess.callsFake((targets: FlowVersionAssessmentTarget[]) => {
+      if (targets.length === 1 && targets[0].versionId === row(1).versionId) {
+        Object.assign(current.flows[0].versions[2], { outcome: 'ERROR', deletable: false, reasonCode: 'OPERATIONAL' });
+      }
+      return targets.map((target) => ({
+        versionId: target.versionId,
+        outcome: 'PASS',
+        reasonCode: null,
+        message: null,
+        evidence: [],
+      }));
+    });
+    const result = await service.execute(plan);
+    expect(result.results.map((item) => item.state)).to.deep.equal(['FAILED', 'SUCCEEDED']);
+    expect(result.results[0].error?.code).to.equal('RETENTION_RECHECK_ERROR');
+    expect(remove.args).to.deep.equal([[row(2).versionId]]);
+  });
+
+  it('retains actual fresh backend blocker evidence while continuing eligible siblings', async () => {
+    const plan = await service.plan({ all: true }, policy);
+    assess.callsFake((targets: FlowVersionAssessmentTarget[]) =>
+      targets.map((target) => ({
+        versionId: target.versionId,
+        outcome: target.versionId === row(1).versionId ? 'BLOCKED' : 'PASS',
+        reasonCode: target.versionId === row(1).versionId ? 'PAUSED_INTERVIEWS' : null,
+        message: target.versionId === row(1).versionId ? 'PAUSED_INTERVIEWS (1)' : null,
+        evidence: [],
+      }))
+    );
+    const result = await service.execute(plan);
+    expect(result.results.map((item) => item.state)).to.deep.equal(['BLOCKED', 'SUCCEEDED']);
+    expect(result.results[0].assessment?.message).to.equal('PAUSED_INTERVIEWS (1)');
+    expect(remove.args).to.deep.equal([[row(2).versionId]]);
+  });
+
+  it('stops all later flows after an uncertain DELETE', async () => {
+    const second = {
+      ...structuredClone(current.flows[0]),
+      definitionId: checksum('300000000000002'),
+      apiName: 'OtherFlow',
+      versions: [row(4), row(5)],
+    };
+    second.versionCount = 2;
+    current.flows.push(second);
+    current.candidateVersionCount = current.returnedVersionCount = 5;
+    list.callsFake((scope: { flowName?: string }) => {
+      const value = structuredClone(current);
+      if (scope.flowName) value.flows = value.flows.filter((flow) => flow.apiName === scope.flowName);
+      return value;
+    });
+    remove.rejects(new FlowVersionDeleteRequestError('NETWORK', 'No response.', false, null, true));
+    const result = await service.execute(await service.plan({ all: true }, policy));
+    expect(result.results.map((item) => item.state)).to.deep.equal(['UNKNOWN', 'NOT_ATTEMPTED', 'NOT_ATTEMPTED']);
+    expect(remove.calledOnce).to.equal(true);
+    expect(result.outcome).to.equal('UNKNOWN');
+  });
+
+  it('binds plans to the originating service/org and rejects mutation/replay', async () => {
+    const plan = await service.plan({ all: true }, policy);
+    await reject(service.execute(structuredClone(plan)), 'INVALID_RETENTION_PLAN');
+    plan.policy.keepLatest = 2;
+    await reject(service.execute(plan), 'INVALID_RETENTION_PLAN');
+    const clean = await service.plan({ all: true }, policy);
+    currentOrg = checksum('00D000000000002');
+    await reject(service.execute(clean), 'ORG_MISMATCH');
+    currentOrg = orgId;
+    await service.execute(clean);
+    await reject(service.execute(clean), 'RETENTION_PLAN_ALREADY_EXECUTED');
+  });
+
+  it('treats a lost execution report as UNKNOWN and stops instead of claiming that nothing happened', async () => {
+    const plan = await service.plan({ all: true }, policy);
+    sandbox.stub(FlowVersionDeleteService.prototype, 'execute').rejects(new Error('Unexpected failure'));
+    const result = await service.execute(plan);
+    expect(result.results.map((item) => item.state)).to.deep.equal(['UNKNOWN', 'NOT_ATTEMPTED']);
+    expect(result.results.every((item) => item.targetDeleted === null)).to.equal(true);
+    expect(result.outcome).to.equal('UNKNOWN');
+  });
+});
diff --git a/test/services/flowVersionTransport.test.ts b/test/services/flowVersionTransport.test.ts
new file mode 100644
index 0000000..c5bfe0b
--- /dev/null
+++ b/test/services/flowVersionTransport.test.ts
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { PassThrough } from 'node:stream';
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { Connection, type AuthInfo } from '@salesforce/core';
+import { FlowVersionService, ToolingFlowVersionClient, type FlowVersionInventory } from '@salesforce/flow-node';
+
+const definitionId = '300000000000001AAA';
+const inventory = (): FlowVersionInventory => ({
+  definitionId,
+  flowName: 'Disposable_Test_Flow',
+  namespace: null,
+  versions: [1, 2, 3].map((versionNumber) => ({
+    definitionId,
+    versionId: `30100000000000${versionNumber}AAA`,
+    flowName: 'Disposable_Test_Flow',
+    namespace: null,
+    versionNumber,
+    status: versionNumber === 1 ? 'Active' : 'Draft',
+  })),
+});
+
+describe('Flow Node through the installed authenticated Connection', () => {
+  const sandbox = sinon.createSandbox();
+  afterEach(() => sandbox.restore());
+
+  const connectionWithResponse = async (
+    statusCode: number,
+    body: string,
+    orgId = '00D000000000001EAA'
+  ): Promise<{ connection: Connection; request: sinon.SinonStub }> => {
+    const connection = new Connection({
+      authInfo: {
+        getUsername: () => 'unit-test-only@example.invalid',
+        getFields: () => ({ orgId }),
+      } as AuthInfo,
+      connectionOptions: {
+        instanceUrl: 'https://flow-poc-unit-test.invalid',
+        accessToken: 'unit-test-only-not-a-credential',
+        version: '67.0',
+      },
+    });
+    await connection.init();
+    // Stub below native HTTP error parsing: no request reaches a network or Salesforce org.
+    // eslint-disable-next-line no-underscore-dangle
+    const request = sandbox.stub(connection._transport, 'httpRequest').callsFake(() =>
+      Object.assign(Promise.resolve({ statusCode, headers: { 'content-type': 'application/json' }, body }), {
+        stream: () => new PassThrough(),
+      })
+    );
+    return { connection, request };
+  };
+
+  it('reads and normalizes the org identity from the native authenticated Connection', async () => {
+    const { connection, request } = await connectionWithResponse(204, '', '00D000000000001');
+    expect(new ToolingFlowVersionClient(connection).getOrgId()).to.equal('00D000000000001EAA');
+    expect(request.called).to.equal(false);
+  });
+
+  it('rejects a foreign-org plan before querying or deleting through a native Connection', async () => {
+    const { connection, request } = await connectionWithResponse(204, '', '00D000000000002EAA');
+    const query = sandbox.stub(connection.tooling, 'query');
+    const sourceClient = {
+      getOrgId: () => '00D000000000001EAA',
+      inventory: async () => inventory(),
+      deleteVersion: sandbox.stub().resolves(),
+    };
+    const plan = await new FlowVersionService(sourceClient).plan({
+      flowName: 'Disposable_Test_Flow',
+      versions: '2',
+    });
+    let error: unknown;
+    try {
+      await new FlowVersionService(new ToolingFlowVersionClient(connection)).execute(plan);
+    } catch (caught) {
+      error = caught;
+    }
+    expect(error).to.be.instanceOf(Error);
+    expect((error as { code: string }).code).to.equal('ORG_MISMATCH');
+    expect(query.called).to.equal(false);
+    expect(request.called).to.equal(false);
+    expect(sourceClient.deleteVersion.called).to.equal(false);
+  });
+
+  it('accepts the real native 204 response and preserves exact endpoint and retry options', async () => {
+    const { connection, request } = await connectionWithResponse(204, '');
+    const client = new ToolingFlowVersionClient(connection);
+    await client.deleteVersion('301000000000002AAA');
+
+    expect(request.calledOnce).to.equal(true);
+    expect(request.firstCall.args[0]).to.include({
+      method: 'DELETE',
+      url: 'https://flow-poc-unit-test.invalid/services/data/v67.0/tooling/sobjects/Flow/301000000000002AAA',
+    });
+    expect(request.firstCall.args[1]).to.include({ followRedirect: false });
+    const requestOptions = request.firstCall.args[1] as { retry: { methods: string[]; maxRetries: number } };
+    expect(requestOptions.retry).to.deep.equal({ methods: [], maxRetries: 0 });
+  });
+
+  it('stops after a native 503 error even when its body has a familiar deletion-rejection code', async () => {
+    const { connection, request } = await connectionWithResponse(
+      503,
+      JSON.stringify([{ errorCode: 'DELETE_FAILED', message: 'The server could not establish the outcome.' }])
+    );
+    const transport = new ToolingFlowVersionClient(connection);
+    const service = new FlowVersionService({
+      getOrgId: () => '00D000000000001EAA',
+      inventory: async () => inventory(),
+      deleteVersion: async (versionId) => transport.deleteVersion(versionId),
+    });
+    const plan = await service.plan({ flowName: 'Disposable_Test_Flow', versions: '2,3' });
+    const report = await service.execute(plan);
+
+    expect(report.outcome).to.equal('UNKNOWN');
+    expect(report.results.map((result) => result.state)).to.deep.equal(['UNKNOWN', 'NOT_ATTEMPTED']);
+    expect(report.results[0].targetDeleted).to.equal(null);
+    expect(report.results[0].error?.code).to.equal('DELETE_FAILED');
+    expect(request.calledOnce).to.equal(true);
+  });
+});
diff --git a/test/ux/confirmation.test.ts b/test/ux/confirmation.test.ts
new file mode 100644
index 0000000..6fa1aaa
--- /dev/null
+++ b/test/ux/confirmation.test.ts
@@ -0,0 +1,202 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { expect } from 'chai';
+import sinon from 'sinon';
+import type inquirerConfirm from '@inquirer/confirm';
+import { ConfirmationPrompt } from '../../src/ux/confirmation.js';
+
+type PromptFunction = typeof inquirerConfirm;
+type ChildResult = {
+  confirmed: boolean;
+  mutations: number;
+  inputPaused: boolean;
+};
+
+async function runRealPrompt(answer?: string): Promise<ChildResult> {
+  const child = spawn(
+    process.execPath,
+    [
+      fileURLToPath(new URL('./fixtures/confirmation-child.mjs', import.meta.url)),
+      answer === undefined ? '50' : '2000',
+    ],
+    { stdio: ['pipe', 'pipe', 'pipe'] }
+  );
+  let output = '';
+  let stderr = '';
+  let answered = false;
+  let inputEnded = false;
+  return new Promise((resolve, reject) => {
+    const watchdog = setTimeout(() => {
+      child.kill('SIGKILL');
+      reject(new Error(`The confirmation child did not exit naturally. Output: ${output}\n${stderr}`));
+    }, 5000);
+    child.once('error', (error) => {
+      clearTimeout(watchdog);
+      reject(error);
+    });
+    child.stdout.on('data', (chunk: Buffer) => {
+      output += chunk.toString();
+      if (answer !== undefined && !answered && output.includes('(y/N)')) {
+        answered = true;
+        child.stdin.write(answer);
+      }
+    });
+    child.stderr.on('data', (chunk: Buffer) => {
+      stderr += chunk.toString();
+    });
+    child.once('exit', () => {
+      inputEnded = child.stdin.writableEnded;
+    });
+    child.once('close', (code, signal) => {
+      clearTimeout(watchdog);
+      try {
+        expect(signal, stderr).to.equal(null);
+        expect(code, stderr).to.equal(0);
+        expect(inputEnded, 'the parent must keep stdin open until the child exits').to.equal(false);
+        const serialized = /CONFIRMATION_RESULT:(\{[^\n]+\})/.exec(output)?.[1];
+        if (!serialized) throw new Error(`Missing confirmation result: ${output}`);
+        resolve(JSON.parse(serialized) as ChildResult);
+      } catch (error) {
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  });
+}
+
+describe('ConfirmationPrompt', () => {
+  const sandbox = sinon.createSandbox();
+  let prompt: sinon.SinonStub<Parameters<PromptFunction>, ReturnType<PromptFunction>>;
+
+  beforeEach(() => {
+    prompt = sandbox.stub<Parameters<PromptFunction>, ReturnType<PromptFunction>>().resolves(false);
+  });
+
+  afterEach(() => sandbox.restore());
+
+  it('uses the standard confirm prompt with a false default and a 60-second deadline', async () => {
+    const clock = sandbox.useFakeTimers();
+    const result = await new ConfirmationPrompt(prompt).confirm({ message: 'Delete the selected versions?' });
+
+    expect(result).to.equal(false);
+    expect(prompt.calledOnce).to.equal(true);
+    expect(prompt.firstCall.args[0]).to.deep.equal({ message: 'Delete the selected versions?', default: false });
+    expect(prompt.firstCall.args[1]?.signal).to.be.instanceOf(AbortSignal);
+    expect(clock.countTimers()).to.equal(0);
+  });
+
+  it('returns explicit confirmation and clears the deadline on success', async () => {
+    const clock = sandbox.useFakeTimers();
+    prompt.resolves(true);
+
+    expect(await new ConfirmationPrompt(prompt).confirm({ message: 'Delete?' })).to.equal(true);
+    expect(clock.countTimers()).to.equal(0);
+  });
+
+  it('aborts the underlying prompt after exactly the default 60-second deadline', async () => {
+    const clock = sandbox.useFakeTimers();
+    const expected = new Error('deadline');
+    expected.name = 'AbortPromptError';
+    prompt.callsFake(
+      (_config, context) =>
+        new Promise((_resolve, reject) => {
+          context?.signal?.addEventListener('abort', () => reject(expected));
+        })
+    );
+    const confirmation = new ConfirmationPrompt(prompt).confirm({ message: 'Delete?' });
+    const signal = prompt.firstCall.args[1]?.signal;
+
+    await clock.tickAsync(59_999);
+    expect(signal?.aborted).to.equal(false);
+    await clock.tickAsync(1);
+    expect(await confirmation).to.equal(false);
+    expect(signal?.aborted).to.equal(true);
+    expect(clock.countTimers()).to.equal(0);
+  });
+
+  it('returns false when the user cancels and clears the deadline', async () => {
+    const clock = sandbox.useFakeTimers();
+    const error = new Error('User force closed the prompt with SIGINT');
+    error.name = 'ExitPromptError';
+    prompt.rejects(error);
+
+    expect(await new ConfirmationPrompt(prompt).confirm({ message: 'Delete?' })).to.equal(false);
+    expect(clock.countTimers()).to.equal(0);
+  });
+
+  it('propagates prompt failures and clears the deadline', async () => {
+    const clock = sandbox.useFakeTimers();
+    const error = new Error('Unexpected prompt failure');
+    prompt.rejects(error);
+    let caught: unknown;
+    try {
+      await new ConfirmationPrompt(prompt).confirm({ message: 'Delete?' });
+    } catch (failure) {
+      caught = failure;
+    }
+
+    expect(caught).to.equal(error);
+    expect(clock.countTimers()).to.equal(0);
+  });
+
+  it('does not swallow an abort error before its own deadline', async () => {
+    const error = new Error('An unrelated prompt abort');
+    error.name = 'AbortPromptError';
+    prompt.rejects(error);
+    let caught: unknown;
+    try {
+      await new ConfirmationPrompt(prompt).confirm({ message: 'Delete?', ms: 1000 });
+    } catch (failure) {
+      caught = failure;
+    }
+
+    expect(caught).to.equal(error);
+  });
+
+  it('rejects a true default before opening a prompt', async () => {
+    let caught: unknown;
+    try {
+      await new ConfirmationPrompt(prompt).confirm({ message: 'Delete?', defaultAnswer: true });
+    } catch (failure) {
+      caught = failure;
+    }
+
+    expect(caught).to.be.instanceOf(TypeError);
+    expect(prompt.called).to.equal(false);
+  });
+
+  it('cleans up a real timed-out prompt and exits naturally with stdin still open', async () => {
+    expect(await runRealPrompt()).to.deep.equal({ confirmed: false, mutations: 0, inputPaused: true });
+  });
+
+  it('accepts yes through the real prompt and exits naturally', async () => {
+    expect(await runRealPrompt('y\n')).to.deep.equal({ confirmed: true, mutations: 1, inputPaused: true });
+  });
+
+  it('accepts no through the real prompt without a mutation', async () => {
+    expect(await runRealPrompt('n\n')).to.deep.equal({ confirmed: false, mutations: 0, inputPaused: true });
+  });
+
+  it('defaults to no on Enter through the real prompt', async () => {
+    expect(await runRealPrompt('\n')).to.deep.equal({ confirmed: false, mutations: 0, inputPaused: true });
+  });
+
+  it('handles Ctrl-C through the real prompt without a mutation', async () => {
+    expect(await runRealPrompt('\u0003')).to.deep.equal({ confirmed: false, mutations: 0, inputPaused: true });
+  });
+});
diff --git a/test/ux/fixtures/confirmation-child.mjs b/test/ux/fixtures/confirmation-child.mjs
new file mode 100644
index 0000000..70cdad9
--- /dev/null
+++ b/test/ux/fixtures/confirmation-child.mjs
@@ -0,0 +1,11 @@
+import { ConfirmationPrompt } from '../../../lib/ux/confirmation.js';
+
+let mutations = 0;
+const confirmed = await new ConfirmationPrompt().confirm({
+  message: 'Confirm the test mutation?',
+  ms: Number(process.argv[2]),
+});
+if (confirmed) mutations += 1;
+process.stdout.write(
+  `CONFIRMATION_RESULT:${JSON.stringify({ confirmed, mutations, inputPaused: process.stdin.isPaused() })}\n`
+);
diff --git a/test/ux/fixtures/force-delete-confirmation-child.mjs b/test/ux/fixtures/force-delete-confirmation-child.mjs
new file mode 100644
index 0000000..1589cc7
--- /dev/null
+++ b/test/ux/fixtures/force-delete-confirmation-child.mjs
@@ -0,0 +1,33 @@
+import { ForceDeleteConfirmationPrompt } from '../../../lib/ux/forceDeleteConfirmation.js';
+import { emitKeypressEvents } from 'node:readline';
+
+// Node installs one shared keypress decoder on first use; it is not a prompt listener.
+// Establish that standard decoder before measuring prompt-owned listener cleanup.
+emitKeypressEvents(process.stdin);
+const bootstrapKeypress = () => undefined;
+process.stdin.on('keypress', bootstrapKeypress);
+process.stdin.removeListener('keypress', bootstrapKeypress);
+process.stdin.pause();
+const before = process.stdin.listenerCount('data');
+const keypressBefore = process.stdin.listenerCount('keypress');
+const rawBefore = process.stdin.isRaw;
+const confirmed = await new ForceDeleteConfirmationPrompt().confirm({
+  flowApiName: 'Fixture_Flow',
+  versionNumber: 12,
+  flowNameMessage: 'TYPE_FLOW_API_NAME:',
+  versionMessage: 'TYPE_VERSION_NUMBER:',
+  output: process.argv[3] === 'stderr' ? process.stderr : process.stdout,
+  ms: Number(process.argv[2]),
+});
+process.stdout.write(
+  `FORCE_CONFIRMATION_RESULT:${JSON.stringify({
+    confirmed,
+    mutations: confirmed ? 1 : 0,
+    inputPaused: process.stdin.isPaused(),
+    inputIsTTY: process.stdin.isTTY,
+    outputIsTTY: process.stdout.isTTY,
+    dataListenerDelta: process.stdin.listenerCount('data') - before,
+    keypressListenerDelta: process.stdin.listenerCount('keypress') - keypressBefore,
+    rawModeRestored: process.stdin.isRaw === rawBefore,
+  })}\n`
+);
diff --git a/test/ux/fixtures/force-delete-confirmation-pty.py b/test/ux/fixtures/force-delete-confirmation-pty.py
new file mode 100644
index 0000000..b67b44d
--- /dev/null
+++ b/test/ux/fixtures/force-delete-confirmation-pty.py
@@ -0,0 +1,57 @@
+"""Exercise the real Node input prompt on an actual PTY, leaving its master open."""
+
+import errno
+import os
+import pty
+import select
+import sys
+import time
+
+node, child_file, mode = sys.argv[1:]
+pid, master = pty.fork()
+if pid == 0:
+    os.execv(node, [node, child_file, "250" if mode.startswith("timeout") else "2000", "stderr" if mode == "stderr-match" else "stdout"])
+
+seen = bytearray()
+flow_answered = False
+version_answered = False
+started = time.monotonic()
+while True:
+    if time.monotonic() - started > 5:
+        os.kill(pid, 9)
+        os.waitpid(pid, 0)
+        raise RuntimeError("The real confirmation prompt did not exit naturally")
+    readable, _, _ = select.select([master], [], [], 0.05)
+    if not readable:
+        continue
+    try:
+        chunk = os.read(master, 65536)
+    except OSError as error:
+        if error.errno != errno.EIO:
+            raise
+        break
+    if not chunk:
+        break
+    seen.extend(chunk)
+    sys.stdout.buffer.write(chunk)
+    sys.stdout.buffer.flush()
+    if not flow_answered and b"TYPE_FLOW_API_NAME:" in seen:
+        flow_answered = True
+        answer = {
+            "match": b"Fixture_Flow\n",
+            "stderr-match": b"Fixture_Flow\n",
+            "mismatch": b"Other_Flow\n",
+            "version-mismatch": b"Fixture_Flow\n",
+            "timeout-version": b"Fixture_Flow\n",
+            "cancel": b"\x03",
+        }.get(mode)
+        if answer is not None:
+            os.write(master, answer)
+    if not version_answered and b"TYPE_VERSION_NUMBER:" in seen:
+        version_answered = True
+        if mode in ("match", "stderr-match", "version-mismatch"):
+            os.write(master, b"012\n" if mode == "version-mismatch" else b"12\n")
+
+_, status = os.waitpid(pid, 0)
+os.close(master)
+sys.exit(os.waitstatus_to_exitcode(status))
diff --git a/test/ux/forceDeleteConfirmation.test.ts b/test/ux/forceDeleteConfirmation.test.ts
new file mode 100644
index 0000000..b7521e2
--- /dev/null
+++ b/test/ux/forceDeleteConfirmation.test.ts
@@ -0,0 +1,319 @@
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { spawn, spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { expect } from 'chai';
+import sinon from 'sinon';
+import {
+  ForceDeleteConfirmationPrompt,
+  type ForceDeleteConfirmationOptions,
+  type ForceDeleteInputPrompt,
+} from '../../src/ux/forceDeleteConfirmation.js';
+
+const options = (): ForceDeleteConfirmationOptions => ({
+  flowApiName: 'Fixture_Flow',
+  versionNumber: 12,
+  flowNameMessage: 'Type the Flow API name:',
+  versionMessage: 'Type the version number:',
+});
+
+type ChildResult = {
+  confirmed: boolean;
+  mutations: number;
+  inputPaused: boolean;
+  inputIsTTY: boolean;
+  outputIsTTY: boolean;
+  dataListenerDelta: number;
+  keypressListenerDelta: number;
+  rawModeRestored: boolean;
+};
+
+async function runRealPrompt(mode: string): Promise<ChildResult> {
+  const child = spawn(
+    'python3',
+    [
+      fileURLToPath(new URL('./fixtures/force-delete-confirmation-pty.py', import.meta.url)),
+      process.execPath,
+      fileURLToPath(new URL('./fixtures/force-delete-confirmation-child.mjs', import.meta.url)),
+      mode,
+    ],
+    { stdio: ['pipe', 'pipe', 'pipe'] }
+  );
+  let output = '';
+  let stderr = '';
+  return new Promise((resolve, reject) => {
+    const watchdog = setTimeout(() => {
+      child.kill('SIGKILL');
+      reject(new Error(`The PTY confirmation child did not exit naturally. Output: ${output}\n${stderr}`));
+    }, 6000);
+    child.once('error', (error) => {
+      clearTimeout(watchdog);
+      reject(error);
+    });
+    child.stdout.on('data', (chunk: Buffer) => {
+      output += chunk.toString();
+    });
+    child.stderr.on('data', (chunk: Buffer) => {
+      stderr += chunk.toString();
+    });
+    child.once('close', (code, signal) => {
+      clearTimeout(watchdog);
+      try {
+        expect(signal, stderr).to.equal(null);
+        expect(code, stderr).to.equal(0);
+        expect(child.stdin.writableEnded, 'the parent leaves the PTY runner input open').to.equal(false);
+        const serialized = /FORCE_CONFIRMATION_RESULT:(\{[^\r\n]+\})/.exec(output)?.[1];
+        if (!serialized) throw new Error(`Missing confirmation result: ${output}`);
+        resolve(JSON.parse(serialized) as ChildResult);
+      } catch (error) {
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  });
+}
+
+describe('ForceDeleteConfirmationPrompt', () => {
+  const sandbox = sinon.createSandbox();
+  let prompt: sinon.SinonStub<Parameters<ForceDeleteInputPrompt>, ReturnType<ForceDeleteInputPrompt>>;
+  let originalInputTTY: PropertyDescriptor | undefined;
+  let originalOutputTTY: PropertyDescriptor | undefined;
+  let originalErrorTTY: PropertyDescriptor | undefined;
+
+  beforeEach(() => {
+    originalInputTTY = Object.getOwnPropertyDescriptor(process.stdin, 'isTTY');
+    originalOutputTTY = Object.getOwnPropertyDescriptor(process.stdout, 'isTTY');
+    originalErrorTTY = Object.getOwnPropertyDescriptor(process.stderr, 'isTTY');
+    Object.defineProperty(process.stdin, 'isTTY', { configurable: true, value: true });
+    Object.defineProperty(process.stdout, 'isTTY', { configurable: true, value: true });
+    Object.defineProperty(process.stderr, 'isTTY', { configurable: true, value: true });
+    prompt = sandbox.stub<Parameters<ForceDeleteInputPrompt>, ReturnType<ForceDeleteInputPrompt>>();
+    prompt.onFirstCall().resolves('Fixture_Flow');
+    prompt.onSecondCall().resolves('12');
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+    if (originalInputTTY) Object.defineProperty(process.stdin, 'isTTY', originalInputTTY);
+    else Reflect.deleteProperty(process.stdin, 'isTTY');
+    if (originalOutputTTY) Object.defineProperty(process.stdout, 'isTTY', originalOutputTTY);
+    else Reflect.deleteProperty(process.stdout, 'isTTY');
+    if (originalErrorTTY) Object.defineProperty(process.stderr, 'isTTY', originalErrorTTY);
+    else Reflect.deleteProperty(process.stderr, 'isTTY');
+  });
+
+  it('requires two exact typed values, with no defaults and one shared two-minute deadline', async () => {
+    const clock = sandbox.useFakeTimers();
+    expect(await new ForceDeleteConfirmationPrompt(prompt).confirm(options())).to.equal(true);
+    expect(prompt.callCount).to.equal(2);
+    expect(prompt.firstCall.args[0]).to.deep.equal({ message: 'Type the Flow API name:' });
+    expect(prompt.secondCall.args[0]).to.deep.equal({ message: 'Type the version number:' });
+    expect(prompt.firstCall.args[1]).to.equal(prompt.secondCall.args[1]);
+    expect(prompt.firstCall.args[1].clearPromptOnDone).to.equal(true);
+    expect(prompt.firstCall.args[1].output).to.equal(process.stdout);
+    expect(prompt.firstCall.args[1].signal).to.be.instanceOf(AbortSignal);
+    expect(clock.countTimers()).to.equal(0);
+  });
+
+  it('uses an explicitly selected interactive stderr for both questions', async () => {
+    expect(await new ForceDeleteConfirmationPrompt(prompt).confirm({ ...options(), output: process.stderr })).to.equal(
+      true
+    );
+    expect(prompt.firstCall.args[1].output).to.equal(process.stderr);
+    expect(prompt.secondCall.args[1].output).to.equal(process.stderr);
+  });
+
+  it('rejects a selected prompt output that is not a terminal', async () => {
+    Object.defineProperty(process.stderr, 'isTTY', { configurable: true, value: false });
+    let caught: unknown;
+    try {
+      await new ForceDeleteConfirmationPrompt(prompt).confirm({ ...options(), output: process.stderr });
+    } catch (error) {
+      caught = error;
+    }
+    expect(caught).to.be.instanceOf(TypeError);
+    expect(prompt.called).to.equal(false);
+  });
+
+  it('rejects a different or case-changed Flow name without asking for a version', async () => {
+    prompt.onFirstCall().resolves('fixture_Flow');
+    expect(await new ForceDeleteConfirmationPrompt(prompt).confirm(options())).to.equal(false);
+    expect(prompt.calledOnce).to.equal(true);
+  });
+
+  it('does not trim or normalize a typed API name', async () => {
+    prompt.onFirstCall().resolves('Fixture_Flow ');
+    expect(await new ForceDeleteConfirmationPrompt(prompt).confirm(options())).to.equal(false);
+    expect(prompt.calledOnce).to.equal(true);
+  });
+
+  it('does not accept a blank Flow name as confirmation', async () => {
+    prompt.onFirstCall().resolves('');
+    expect(await new ForceDeleteConfirmationPrompt(prompt).confirm(options())).to.equal(false);
+  });
+
+  for (const value of ['012', '12 ', ' 12', '13', '']) {
+    it(`rejects non-exact version text ${JSON.stringify(value)}`, async () => {
+      prompt.onSecondCall().resolves(value);
+      expect(await new ForceDeleteConfirmationPrompt(prompt).confirm(options())).to.equal(false);
+    });
+  }
+
+  it('requires interactive stdin and stdout before starting either prompt', async () => {
+    Object.defineProperty(process.stdin, 'isTTY', { configurable: true, value: false });
+    let error: unknown;
+    try {
+      await new ForceDeleteConfirmationPrompt(prompt).confirm(options());
+    } catch (caught) {
+      error = caught;
+    }
+    expect(error).to.be.instanceOf(TypeError);
+    expect(prompt.called).to.equal(false);
+    Object.defineProperty(process.stdin, 'isTTY', { configurable: true, value: true });
+    Object.defineProperty(process.stdout, 'isTTY', { configurable: true, value: false });
+    error = undefined;
+    try {
+      await new ForceDeleteConfirmationPrompt(prompt).confirm(options());
+    } catch (caught) {
+      error = caught;
+    }
+    expect(error).to.be.instanceOf(TypeError);
+    expect(prompt.called).to.equal(false);
+  });
+
+  it('does not continue when the terminal context changes after the first prompt', async () => {
+    prompt.onFirstCall().callsFake(async () => {
+      Object.defineProperty(process.stdout, 'isTTY', { configurable: true, value: false });
+      return 'Fixture_Flow';
+    });
+    let error: unknown;
+    try {
+      await new ForceDeleteConfirmationPrompt(prompt).confirm(options());
+    } catch (caught) {
+      error = caught;
+    }
+    expect(error).to.be.instanceOf(TypeError);
+    expect(prompt.calledOnce).to.equal(true);
+  });
+
+  it('does not confirm when the terminal context changes after the exact version was entered', async () => {
+    prompt.onSecondCall().callsFake(async () => {
+      Object.defineProperty(process.stdout, 'isTTY', { configurable: true, value: false });
+      return '12';
+    });
+    let caught: unknown;
+    try {
+      await new ForceDeleteConfirmationPrompt(prompt).confirm(options());
+    } catch (error) {
+      caught = error;
+    }
+    expect(caught).to.be.instanceOf(TypeError);
+    expect(prompt.callCount).to.equal(2);
+  });
+
+  it('uses a single deadline without resetting it for the second question', async () => {
+    const clock = sandbox.useFakeTimers();
+    prompt.onFirstCall().callsFake(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 90_000));
+      return 'Fixture_Flow';
+    });
+    prompt.onSecondCall().callsFake(
+      (_config, { signal }) =>
+        new Promise((_resolve, reject) => {
+          signal.addEventListener('abort', () =>
+            reject(Object.assign(new Error('deadline'), { name: 'AbortPromptError' }))
+          );
+        })
+    );
+    const confirmation = new ForceDeleteConfirmationPrompt(prompt).confirm(options());
+    await clock.tickAsync(90_000);
+    expect(prompt.callCount).to.equal(2);
+    await clock.tickAsync(29_999);
+    expect(prompt.secondCall.args[1].signal.aborted).to.equal(false);
+    await clock.tickAsync(1);
+    expect(await confirmation).to.equal(false);
+    expect(clock.countTimers()).to.equal(0);
+  });
+
+  it('cleans up its deadline when the user cancels', async () => {
+    const clock = sandbox.useFakeTimers();
+    prompt.onSecondCall().rejects(Object.assign(new Error('cancelled'), { name: 'ExitPromptError' }));
+    expect(await new ForceDeleteConfirmationPrompt(prompt).confirm(options())).to.equal(false);
+    expect(clock.countTimers()).to.equal(0);
+  });
+
+  it('does not swallow an unrelated prompt failure or abort', async () => {
+    const clock = sandbox.useFakeTimers();
+    const expected = Object.assign(new Error('unrelated failure'), { name: 'AbortPromptError' });
+    prompt.onFirstCall().rejects(expected);
+    let caught: unknown;
+    try {
+      await new ForceDeleteConfirmationPrompt(prompt).confirm(options());
+    } catch (error) {
+      caught = error;
+    }
+    expect(caught).to.equal(expected);
+    expect(clock.countTimers()).to.equal(0);
+  });
+
+  for (const invalid of [
+    { flowApiName: 'Flow\nInjected' },
+    { versionNumber: 0 },
+    { versionNumber: 1.2 },
+    { flowNameMessage: '' },
+    { versionMessage: '' },
+    { ms: 0 },
+    { ms: Number.NaN },
+    { ms: 2_147_483_648 },
+  ]) {
+    it(`rejects invalid confirmation input ${JSON.stringify(invalid)} before prompting`, async () => {
+      let caught: unknown;
+      try {
+        await new ForceDeleteConfirmationPrompt(prompt).confirm({ ...options(), ...invalid });
+      } catch (error) {
+        caught = error;
+      }
+      expect(caught).to.be.instanceOf(TypeError);
+      expect(prompt.called).to.equal(false);
+    });
+  }
+
+  const hasPtyAndPython =
+    process.platform !== 'win32' && spawnSync('python3', ['--version'], { stdio: 'ignore' }).status === 0;
+  const ptyTest = hasPtyAndPython ? it : it.skip;
+  for (const mode of [
+    'match',
+    'stderr-match',
+    'mismatch',
+    'version-mismatch',
+    'cancel',
+    'timeout-flow',
+    'timeout-version',
+  ]) {
+    ptyTest(`releases the real terminal after ${mode} (requires POSIX PTY and Python3)`, async () => {
+      expect(await runRealPrompt(mode)).to.deep.equal({
+        confirmed: mode === 'match' || mode === 'stderr-match',
+        mutations: mode === 'match' || mode === 'stderr-match' ? 1 : 0,
+        inputPaused: true,
+        inputIsTTY: true,
+        outputIsTTY: true,
+        dataListenerDelta: 0,
+        keypressListenerDelta: 0,
+        rawModeRestored: true,
+      });
+    });
+  }
+});
diff --git a/yarn.lock b/yarn.lock
index b4a239a..b271640 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -717,6 +717,11 @@
   resolved "https://registry.yarnpkg.com/@inquirer/ansi/-/ansi-1.0.2.tgz#674a4c4d81ad460695cb2a1fc69d78cd187f337e"
   integrity sha512-S8qNSZiYzFd0wAcyG5AXCvUHC5Sr7xpZ9wZ2py9XR88jUz8wooStVx5M6dRzczbBWjic9NP7+rY0Xi7qqK/aMQ==
 
+"@inquirer/ansi@^2.0.10":
+  version "2.0.10"
+  resolved "https://registry.yarnpkg.com/@inquirer/ansi/-/ansi-2.0.10.tgz#25f81ba9e13423a6b9419489690321330a545c90"
+  integrity sha512-dwrc+1aqVZpHNkNDswXGtn1typ+Pxpo5FHZRyBw1le7onEJUkPUkYOY1FIFC1LvFMYUqqLuWBwElhAmencL7MQ==
+
 "@inquirer/ansi@^2.0.7":
   version "2.0.7"
   resolved "https://registry.yarnpkg.com/@inquirer/ansi/-/ansi-2.0.7.tgz#86de22810cac3ed406ec10f8d66016815b8226b4"
@@ -784,6 +789,19 @@
     mute-stream "^3.0.0"
     signal-exit "^4.1.0"
 
+"@inquirer/core@^12.0.6":
+  version "12.0.6"
+  resolved "https://registry.yarnpkg.com/@inquirer/core/-/core-12.0.6.tgz#7b426c029925817f3ec333e7dbb146aecbff144c"
+  integrity sha512-5yxn2LsJ8Tu4ei2a+yNkmFRhM/cb+JMEsEs/AW6CCOnBnpMy4IjYiPMFyHtYq8weOmlTyqqCx40y0DsD7OsEPw==
+  dependencies:
+    "@inquirer/ansi" "^2.0.10"
+    "@inquirer/figures" "^2.0.10"
+    "@inquirer/type" "4.2.1"
+    cli-width "^4.1.0"
+    fast-wrap-ansi "^0.2.0"
+    mute-stream "^3.0.0"
+    signal-exit "^4.1.0"
+
 "@inquirer/core@^9.1.0":
   version "9.2.1"
   resolved "https://registry.yarnpkg.com/@inquirer/core/-/core-9.2.1.tgz#677c49dee399c9063f31e0c93f0f37bddc67add1"
@@ -843,6 +861,11 @@
   resolved "https://registry.yarnpkg.com/@inquirer/figures/-/figures-1.0.11.tgz#4744e6db95288fea1dead779554859710a959a21"
   integrity sha512-eOg92lvrn/aRUqbxRyvpEWnrvRuTYRifixHkYVpJiygTgVSBIHDqLh0SrMQXkafvULg3ck11V7xvR+zcgvpHFw==
 
+"@inquirer/figures@^2.0.10":
+  version "2.0.10"
+  resolved "https://registry.yarnpkg.com/@inquirer/figures/-/figures-2.0.10.tgz#1e581e89cdc1dd08e14c1ff4b4ec5184b12fd045"
+  integrity sha512-51elrUJV3jZpvD0ygz8+U10Kc6+Lzqln+/tYmnbhy6jo5oXpE6hMCcv+OTBC0enwJXsb3JIuT3VtEinRNCSK2A==
+
 "@inquirer/figures@^2.0.7":
   version "2.0.7"
   resolved "https://registry.yarnpkg.com/@inquirer/figures/-/figures-2.0.7.tgz#f5cc5843732a81304d06a0db4b53cc7dbda15541"
@@ -864,6 +887,14 @@
     "@inquirer/core" "^10.3.2"
     "@inquirer/type" "^3.0.10"
 
+"@inquirer/input@^5.1.9":
+  version "5.1.9"
+  resolved "https://registry.yarnpkg.com/@inquirer/input/-/input-5.1.9.tgz#b300a9db089d8a3867e2bcbbafd2e060fac006cb"
+  integrity sha512-2Vd5T7lTxfgJMpAd3aOu6bQpbUnCU7tBgvTQIZkP/7juJzmRmTM2t5XfOCuirFduWLTSJI/WZp32Cq1E01TVeg==
+  dependencies:
+    "@inquirer/core" "^12.0.6"
+    "@inquirer/type" "4.2.1"
+
 "@inquirer/number@^3.0.23":
   version "3.0.23"
   resolved "https://registry.yarnpkg.com/@inquirer/number/-/number-3.0.23.tgz#3fdec2540d642093fd7526818fd8d4bdc7335094"
@@ -956,6 +987,11 @@
     "@inquirer/type" "^3.0.10"
     yoctocolors-cjs "^2.1.3"
 
+"@inquirer/type@4.2.1":
+  version "4.2.1"
+  resolved "https://registry.yarnpkg.com/@inquirer/type/-/type-4.2.1.tgz#ef7de2070d26e0e3f1c558b9e3939eab147717a3"
+  integrity sha512-lDkPsnv5M5CcYB2T1qTc3dobNTPkVr4DU3Ic2Q6SW8/qVRHgvzdRdmVZ6YqG9Ag1aJTeMsLU0s0WPRh3CZWDQQ==
+
 "@inquirer/type@^1.5.3":
   version "1.5.5"
   resolved "https://registry.yarnpkg.com/@inquirer/type/-/type-1.5.5.tgz#303ea04ce7ad2e585b921b662b3be36ef7b4f09b"
@@ -1048,7 +1084,7 @@
     "@jridgewell/resolve-uri" "^3.1.0"
     "@jridgewell/sourcemap-codec" "^1.4.14"
 
-"@jsforce/jsforce-node@^3.10.17":
+"@jsforce/jsforce-node@^3.10.17", "@jsforce/jsforce-node@^3.12.0":
   version "3.13.1"
   resolved "https://registry.yarnpkg.com/@jsforce/jsforce-node/-/jsforce-node-3.13.1.tgz#f7780c42d711a59ec33ba961279b37c15e7d0e44"
   integrity sha512-vpHhwc+Wcufk9vARzL4oxYSzg8ndNButSn88D6pMImjns7/NTkwPZ9qQwD2F/P4c+A0lwTyDl4Alry0BMgFsTg==
@@ -1426,6 +1462,31 @@
     ts-retry-promise "^0.8.1"
     zod "^4.1.12"
 
+"@salesforce/core@^9.4.1":
+  version "9.4.4"
+  resolved "https://registry.yarnpkg.com/@salesforce/core/-/core-9.4.4.tgz#4c0a08a9d08401f0c3780386b96804e56a3a3be1"
+  integrity sha512-o7J/121I756oVf9+ZHLvZ06x8d3keK+Ix3Dln3k/UQzmhkp3gk1zp7PdDBq1CR87DFbQMYtftvIccYZHbO7jmg==
+  dependencies:
+    "@jsforce/jsforce-node" "^3.12.0"
+    "@salesforce/kit" "^4.0.0"
+    "@salesforce/ts-types" "^3.2.0"
+    ajv "^8.18.0"
+    change-case "^4.1.2"
+    fast-levenshtein "^3.0.0"
+    faye "^1.4.1"
+    form-data "^4.0.5"
+    js2xmlparser "^4.0.1"
+    jsonwebtoken "9.0.3"
+    jszip "3.10.1"
+    memfs "4.38.1"
+    pino "^9.7.0"
+    pino-abstract-transport "^1.2.0"
+    pino-pretty "^11.3.0"
+    proper-lockfile "^4.1.2"
+    semver "^7.8.0"
+    ts-retry-promise "^0.8.1"
+    zod "^4.1.12"
+
 "@salesforce/dev-config@^4.3.3":
   version "4.3.3"
   resolved "https://registry.yarnpkg.com/@salesforce/dev-config/-/dev-config-4.3.3.tgz#65650087baa542a905ad4e8b38a5c5302f7f009a"
@@ -1467,6 +1528,12 @@
     typescript "^6.0.0"
     wireit "^0.14.13"
 
+"@salesforce/flow-node@git+https://github.com/forcedotcom/flows.git#98a0fe5a2611d20cf62c589388b3f887394162f4":
+  version "0.1.0"
+  resolved "git+https://github.com/forcedotcom/flows.git#98a0fe5a2611d20cf62c589388b3f887394162f4"
+  dependencies:
+    "@salesforce/core" "^9.4.1"
+
 "@salesforce/kit@^3.2.3", "@salesforce/kit@^3.2.4":
   version "3.2.4"
   resolved "https://registry.yarnpkg.com/@salesforce/kit/-/kit-3.2.4.tgz#69fb56974685e41d26ae5db30a7261acdc731bb6"
@@ -1549,6 +1616,11 @@
   resolved "https://registry.yarnpkg.com/@salesforce/ts-types/-/ts-types-3.0.0.tgz#375b13e92f594bc9d0a09716d77fc753bd31e6a6"
   integrity sha512-lTCoI1NtQWiMDyn7B9N/CfWK9WmSpRnbYWqKTZYstn3mZ2DWSYwJXTh5Oh2wAAS9LAD/vaoU3F/TrV3q7wfnYw==
 
+"@salesforce/ts-types@^3.2.0":
+  version "3.2.4"
+  resolved "https://registry.yarnpkg.com/@salesforce/ts-types/-/ts-types-3.2.4.tgz#783db051f0f95a23647934efc521cf1ad31dcdbd"
+  integrity sha512-kTzgXQbOdon0gJFwdHQ+A+UvMR/E3zzlj6O1Wyl5//waq7OSNjspB49y9LrZefIyqHV+ACfB9/aWBJ9aSKMrvQ==
+
 "@shikijs/engine-oniguruma@^3.23.0":
   version "3.23.0"
   resolved "https://registry.yarnpkg.com/@shikijs/engine-oniguruma/-/engine-oniguruma-3.23.0.tgz#789421048d66ac1b33613169d6d18b9cc6e340ed"
@@ -2160,7 +2232,7 @@ aggregate-error@^3.0.0:
     clean-stack "^2.0.0"
     indent-string "^4.0.0"
 
-ajv@^6.14.0:
+ajv@^6.12.6, ajv@^6.14.0:
   version "6.15.0"
   resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.15.0.tgz#07e982c74626167aa7a2495c53817892d7139492"
   integrity sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==