# ForgePack CLI Reference

Status: Stage 10 V1 freeze candidate

The `fp` tool exposes the supported ForgePack workflows. Output is plain text
and intended to remain stable for simple scripts.

## Global Commands

```text
fp --help
fp --version
fp --format-version
fp codecs
fp codecs --json
fp codecs --all
fp codecs --json --all
fp versions
fp versions --json
fp policy-families [--json]
fp policy-family-hint <family> [--json]
fp policy-hint <path> [--json]
fp policy-runtime <path> [--json] [--profile store|fast|balanced|max|forensic-safe]
```

`fp --format-version` prints the archive format version.

`fp codecs` lists available codec backends:

```text
raw version=1 compress=yes decompress=yes
zlib version=1 compress=yes decompress=yes
```

`fp codecs --all` also lists reserved codec IDs such as Zstd and LZ4 with
`available=no`. Reserved entries are not selectable payload backends until their
optional backend gates pass.

`fp policy-hint` prints the compact path-to-family policy contract. `fp
policy-runtime` prints the resolved runtime policy for benchmark and diagnostic
tooling: sampled bytes, classification source, classification confidence,
text subfamily, content class, action, candidate methods, and regression gate
thresholds. Use `--profile max` or another
ForgePack profile to inspect non-default policy behavior without exposing raw
backend codec levels as user-facing product choices.
The command also reports pre-resolution evidence such as byte-signature family,
path-suffix family, suffix/signature conflict, and explicit override flags for
Office ZIP containers or non-text suffixes over plain-text samples.
`evidenceStatus` condenses that evidence to `clean`, `path-override`,
`conflict`, `heuristic`, or `unknown` for simpler CI reporting.
`evidenceReview` is the boolean gate helper: controlled overrides are accepted,
while ambiguous or heuristic-only classifications are flagged for review.
The output includes `buildType`, `releaseBuild`, and `debugBuild` so
performance gates can fail fast when accidentally executed against a debug
binary.

## Pack

```text
fp pack <input-file-or-directory> <archive.fp> [options]
```

Options:

- `--compression raw|zlib|zerorun|lz4|zstd|brotli|lzma2|auto`
- `--compression-profile store|fast|balanced|max|forensic-safe`
- `--choose-smallest`
- `--compression-level 1..22`
- `--chunk-size bytes`
- `--cold-metadata`
- `--manifest-placeholder`
- `--payload-integrity`
- `--recovery none|light|medium|heavy`
- `--dry-run`
- `--json` with `--dry-run`
- `--paths-only` with `--dry-run`

Defaults:

- compression: `raw`
- zlib compression level: `6`
- chunking: disabled unless `--chunk-size` is provided
- no cold metadata
- no manifest placeholder
- no payload integrity
- recovery: `none`

`--dry-run` collects and normalizes the input dataset, prints a summary, and
does not build or write the archive file. Use it for quick path/input checks
before running a heavier compression job.
The summary includes regular file count, directory count, empty/non-empty file
counts, logical input bytes, largest regular file size, and average regular
file size. When `--chunk-size` is provided, dry-run also reports the estimated
number of archive chunks that would be produced.

`--dry-run --json` emits the same preview as a JSON object for CI and local
automation. `--json` is intentionally rejected for normal pack operations.
The JSON form includes an `items` array with type, size, and normalized path,
plus a compact `paths` array for scripts that only need path values.
`--dry-run --paths-only` prints one normalized archive path per line and does
not build or write the archive.
Dry-run output also includes the selected compression method, adaptive profile,
zlib level, chunk size, selector flags, metadata toggles, payload integrity, and
recovery mode, so automation can confirm the exact planned pack configuration
before the archive is written.

## List

```text
fp list <archive.fp> [--json] [--verbose] [--summary] [--paths-only]
```

Output format:

```text
<type> <uncompressed-size> <archive-path>
```

With `--verbose`:

```text
<type> <uncompressed-size> stored=<stored-size> chunks=<chunk-count> compression=<method> mixed-compression=<yes|no> <archive-path>
```

With `--summary`, list prints aggregate counters before entries:

```text
entries <count>
regular-files <count>
directories <count>
empty-files <count>
non-empty-files <count>
total-size <bytes>
total-stored-size <bytes>
total-chunks <count>
total-storage-ratio-permille <ratio>
largest-file-uncompressed <bytes>
largest-file-stored <bytes>
average-file-uncompressed <bytes>
average-file-stored <bytes>
```

With `--paths-only`, list prints one archive path per line without type or size
columns. This is intended for shell scripts and manifest comparisons.
`--summary --paths-only` prints aggregate counters first, then path-only rows.
`--verbose --paths-only` is rejected because path-only rows intentionally omit
per-entry detail columns.

Known types:

- `file`
- `dir`
- `symlink` reserved
- `hardlink` reserved

`--json` emits a single object with summary counters and an `entries` array.
Top-level counters include `entryCount`, `regularFiles`, `directories`,
`emptyFiles`, `nonEmptyFiles`, `totalSize`, `totalStoredSize`, and
`totalChunks`. Size distribution counters include `largestFileUncompressed`,
`largestFileStored`, `averageFileUncompressed`, and `averageFileStored`.
`totalStorageRatioPermille` reports stored bytes divided by logical bytes.
The JSON form includes a compact `paths` array and full `entries` objects.
Each entry contains `type`, `size`, `storedSize`, `chunks`, `compression`,
`mixedCompression`, and `path`.
`fp manifest --json` follows the same `paths` plus `entries` structure.
`fp manifest --summary --paths-only` prints aggregate counters first, then
path-only rows. `--json` is mutually exclusive with the other manifest output
modifiers.

## Extract

## Stat

```text
fp stat <archive.fp> <archive-path> [--json|--paths-only|--exists|--type-only|--size-only|--stored-size-only|--chunks-only|--ratio-only|--compression-only|--mixed-compression-only]
```

Looks up one archive entry and reports `archive`, `path`, `type`, logical size,
stored size, chunk count, and storage ratio. JSON output includes `ok: true`.
Text and JSON output also include boolean regular-file/directory flags for
simpler scripting.
On lookup failure, `--json` emits `ok: false`, the requested path, and the
stable ForgePack error text.
`--paths-only` prints only the normalized matching archive path.
Scalar modes print one value and are intended for scripts:
`--exists`, `--type-only`, `--size-only`, `--stored-size-only`, `--chunks-only`,
and `--ratio-only`.
This is intended for random-access metadata checks without parsing the full
list output.
Text and JSON output include `compression` and mixed-compression status. The
scalar `--compression-only` mode prints only the first compression method for
the selected entry. `--mixed-compression-only` prints `yes` or `no`.

## Cat

```text
fp cat <archive.fp> <archive-path> [--output file] [--overwrite] [--dry-run] [--json]
```

Writes one regular file entry to stdout. Directories and non-file entries are
rejected with `unsupported operation`.
With `--output`, the selected file is written to the requested path. Existing
files are rejected unless `--overwrite` is also provided.
With `--dry-run`, the selected file is validated and summarized without writing
payload bytes. The summary reports path, payload size, stored size, and chunk
count, plus first compression method. `--dry-run --json` emits the same summary
as a stable JSON object including `compression` and `mixedCompression`.
`--json` is only valid together with `--dry-run`.

## Compare

```text
fp compare <left.fp> <right.fp> [--json|--summary|--metrics|--labels|--counts-only|--paths-only|--left-only|--right-only|--changed-only|--logical-changed-only|--storage-changed-only|--same-only|--severity-only|--drift-class-only|--dominant-class-only|--difference-permille-only|--matched-permille-only|--unchanged-permille-only|--left-only-permille-only|--right-only-permille-only|--changed-permille-only|--logical-changed-permille-only|--storage-changed-permille-only|--quiet] [--path-exact path] [--path-contains text] [--path-prefix prefix] [--path-suffix suffix] [--entry-filter all|files|directories] [--path-list-limit count] [--fail-on-truncated-path-lists] [--logical-only] [--ignore-type] [--ignore-uncompressed-size] [--ignore-stored-size] [--ignore-chunks] [--ignore-compression-method] [--no-path-lists] [--allow-storage-only] [--exit-zero] [--allow-drift-up-to none|low|moderate|high] [--allow-severity-up-to none|storage-only|logical] [--allow-differences-up-to count] [--allow-difference-permille-up-to value] [--require-matched-permille-at-least value]
```

Compares two archives by entry metadata without extracting payload bytes. The
command reports whether the archives are equal, entry counts, matched entries,
left-only/right-only entries, and type/size/stored-size/chunk differences.
`--path-exact <path>` limits the comparison to one archive path.
`--path-contains <text>` limits the comparison to paths containing the selected
substring.
`--path-prefix <prefix>` limits the comparison to archive paths that start with
the selected prefix; all counters and ratios then describe only that filtered
view.
`--path-suffix <suffix>` limits the comparison to archive paths ending with the
selected suffix. Prefix and suffix filters can be combined.
`--entry-filter` limits the comparison to all entries, regular files only, or
directories only.
Equal archives return exit code `0`; metadata differences return a non-zero
exit code so the command can be used as a CI gate.
The `severity` field is `none`, `storage-only`, or `logical`.
`--summary` emits a compact one-line result with equality and difference-class
counts.
`--counts-only` emits five numbers: total differences, left-only, right-only,
changed matched paths, and unchanged matched paths.
`--metrics` emits stable `forgepack_compare_*` metric lines suitable for simple
CI collectors and shell pipelines. It includes classification ids, entry counts,
difference counts, path-list truncation state, and permille ratios.
`--labels` emits stable label lines for semantic compare classification:
`severity`, `drift-class`, `dominant-class`, and `path-lists-truncated`.
`--summary` includes `logical-changed` and `storage-changed` counters so release
logs can show whether matched paths differ by payload shape, storage metadata,
or both.
Compare text, summary, and JSON output also expose permille metrics:
`matchedPermille`, `differencePermille`, and `unchangedPermille`. They are
integer values in the `0..1000` range and use the distinct path count as the
denominator.
Class-specific permille fields are also exposed for left-only, right-only,
changed, logical-changed, and storage-changed entries.
`driftClass` is a derived scale label (`none`, `low`, `moderate`, `high`) based
on `differencePermille`; it is intended for dashboards and release summaries.
`dominantClass` reports which difference category dominates the result:
`left-only`, `right-only`, `logical-changed`, `storage-changed`, or `mixed`.
`--json` emits the same fields as a single object using stable camelCase names:
`ok`, `leftArchive`, `rightArchive`, `logicalOnly`, `allowStorageOnly`,
`severity`, `equal`, `differences`, `leftEntries`, `rightEntries`, `matchedEntries`,
`leftOnly`, `rightOnly`, `changed`, `unchanged`, `typeDifferences`, `sizeDifferences`,
`storedSizeDifferences`, `chunkDifferences`, and
`compressionMethodDifferences`.
It also includes `leftOnlyPaths`, `rightOnlyPaths`, and `changedPaths` arrays so
machine consumers do not need to run a second path-only command.
`--paths-only` emits only differing archive paths: left-only paths, right-only
paths, then changed paths. It keeps the same exit-code policy as the default
mode.
`--left-only`, `--right-only`, `--changed-only`, `--logical-changed-only`,
`--storage-changed-only`, and `--same-only` narrow the path output to a single
difference class for scripting and release diagnostics.
`--drift-class-only` prints only the derived drift class label.
`--difference-permille-only` prints only the integer difference ratio, which is
useful for simple metrics collectors.
`--matched-permille-only` and `--unchanged-permille-only` expose the matching
and unchanged ratios with the same integer convention.
`--changed-permille-only`, `--logical-changed-permille-only`, and
`--storage-changed-permille-only` expose class-specific changed ratios for
metrics collection.
`--left-only-permille-only` and `--right-only-permille-only` expose unmatched
path ratios.
`--severity-only` prints only the semantic severity label: `none`,
`storage-only`, or `logical`.
JSON output includes `logicalChanged`, `storageChanged`,
`logicalChangedPaths`, and `storageChangedPaths` so CI can distinguish payload
shape differences from codec/container storage differences.
`--logical-only` ignores storage representation differences such as stored size,
chunk count, and compression method.
`--ignore-type` and `--ignore-uncompressed-size` suppress the two logical
matched-entry checks independently. They are intended for targeted diagnostics,
not for normal release equivalence gates.
`--ignore-stored-size`, `--ignore-chunks`, and `--ignore-compression-method`
disable individual storage metadata checks without hiding every storage
difference class.
`--no-path-lists` keeps counters and derived metrics, but suppresses path vector
collection. It is rejected with path-list output modes such as `--paths-only`.
`--path-list-limit <count>` caps each emitted path list independently. JSON
includes `pathListsTruncated` when a cap removes entries from any path list.
`--fail-on-truncated-path-lists` makes truncation fail the command even when
`--exit-zero` is present.
`--allow-storage-only` keeps output unchanged but returns success for
`storage-only` differences while still failing on logical differences.
`--exit-zero` keeps output unchanged but returns success for any successfully
computed comparison. I/O and archive parsing errors still fail, so the option is
safe for CI report collection stages that should not gate on differences.
`--allow-drift-up-to <class>` returns success when the computed drift class is
at most the selected threshold. This is stricter than `--exit-zero` and is meant
for release gates that tolerate small metadata drift but still fail on larger
archive changes.
`--allow-severity-up-to <severity>` returns success when the computed severity
is not higher than the selected threshold. Accepted values are `none`,
`storage-only`, and `logical`.
`--allow-differences-up-to <count>` returns success when the total difference
count is not higher than the selected threshold.
`--allow-difference-permille-up-to <value>` returns success when the integer
difference ratio is not higher than the selected threshold. The value is in
permille and must be in the `0..1000` range.
`--require-matched-permille-at-least <value>` returns success only when the
integer matched-path ratio is at least the selected threshold. The value is in
permille and must be in the `0..1000` range.
`--quiet` suppresses stdout and uses only the exit code.
When `--json` is used and either archive cannot be read or parsed, the command
emits `ok: false`, the failing `archive`, and the stable ForgePack `error`.

## Extract

```text
fp extract <archive.fp> <output-dir> [--overwrite] [--dry-run] [--json|--paths-only]
```

Default extraction refuses to overwrite existing files.
`--dry-run` decodes the archive, validates target paths against the output
directory, and prints a short summary without writing files.
`--dry-run --json` emits the same summary as a JSON object.
The JSON form includes an `items` array with type, size, stored size, chunk
count, and path, plus a compact `paths` array for scripts that only need path
values.
`--dry-run --paths-only` prints one archive path per line and does not create
files or directories.
Dry-run summaries include regular file count, directory count, empty/non-empty
file counts, logical bytes, stored bytes, chunk count, and storage ratio in
permille. They also report largest and average regular file size.

## Extract One

```text
fp extract-one <archive.fp> <archive-path> <output-dir> [--overwrite] [--dry-run] [--json|--paths-only]
```

Extracts one selected archive entry. Current implementation reuses the full
selected-entry decode path and writes only that entry. Directory entries create
directories rather than placeholder files.

`--dry-run` follows the same selected-entry decode and path validation path, but
does not create files or directories.
`--dry-run --json` emits the selected-entry dry-run summary as a JSON object.
The JSON form includes a one-element `items` array and a one-element `paths`
array for the selected entry.
`--dry-run --paths-only` prints only the selected archive path.
Selected-entry dry-run summaries include regular file count, directory count,
empty/non-empty file counts, logical bytes, stored bytes, chunk count, and
storage ratio in permille. They also report largest and average regular file
size.

## Test and Verify

```text
fp test <archive.fp> [--json|--summary|--paths-only]
fp verify <archive.fp> [--json|--summary|--paths-only]
```

Both commands validate the archive through the SDK verification path. Payload
integrity is checked when integrity metadata is present.

`--json` emits a single validation object to stdout. On success, `ok` is `true`
and the object includes `entries`, `regularFiles`, `directories`, `emptyFiles`,
`nonEmptyFiles`, `chunks`, `verifiedStoredBytes`, and `verifiedPayloadBytes`.
`verifiedStorageRatioPermille` reports verified stored bytes divided by verified
payload bytes on the same permille scale as `fp info`. On failure, `ok` is
`false` and `error` contains the stable ForgePack error text.
On success, the JSON form also includes an `items` array with type, size,
stored size, chunk count, and path, plus a compact `paths` array.

`--summary` emits stable text fields for the same success counters without the
default compact prose line. The summary includes the archive path so stored
reports remain self-contained.
`--paths-only` validates the archive first, then prints one archive path per
line.

## Info

```text
fp info <archive.fp> [--json|--summary]
```

Reports format, metadata, payload, recovery, append, and sidecar information.
`--summary` prints only the main archive, payload, compression, and release-gate
counters.

## Manifest

```text
fp manifest <archive.fp> [--json|--summary|--paths-only]
```

The text and JSON forms include aggregate file counters: entries, regular
files, directories, empty files, non-empty files, total logical size, total
stored size, and total chunk count.
`--summary` prints only aggregate counters.
`--paths-only` prints one archive path per line.

## Exit Codes

Stage 10 V1 freeze candidate uses:

- `0`: command completed successfully
- `1`: command failed

Error details are printed to stderr using stable ForgePack error text where
possible.

## `fp info` Size and Codec Metrics

`fp info <archive.fp>` reports release-oriented metrics in addition to section
presence:

- `size` - archive byte size
- `total-uncompressed` - sum of original chunk sizes
- `total-stored` - sum of stored chunk sizes
- `empty-files` - regular files with zero original bytes
- `non-empty-files` - regular files with at least one original byte
- `min-chunks-per-file` - minimum chunk count among regular files
- `average-chunks-per-file` - average chunk count among regular files
- `max-chunks-per-file` - maximum chunk count among regular files
- `largest-file-uncompressed` - largest regular file original size
- `largest-file-stored` - largest regular file stored payload size
- `average-file-uncompressed` - average regular file original size
- `average-file-stored` - average regular file stored payload size
- `container-overhead` - bytes not counted as stored payload chunks
- `metadata-total` - bytes occupied by hot metadata and optional metadata sections
- `metadata-archive-share-permille` - metadata share of the archive size
- `raw-chunks` - chunks using the raw codec
- `zlib-chunks` - chunks using the zlib codec
- `lz4-chunks`, `zstd-chunks`, `brotli-chunks`, `lzma2-chunks` - chunks using optional backends
- `zerorun-chunks` - chunks using the built-in zero-run codec
- `ppmd-chunks` - chunks using the reserved PPMd text-specialist codec ID
- `raw-uncompressed` / `raw-stored` - logical and stored bytes classified as raw
- `zlib-uncompressed` / `zlib-stored` - logical and stored bytes classified as zlib
- `zerorun-uncompressed` / `zerorun-stored` - logical and stored bytes classified as zero-run
- `ppmd-uncompressed` / `ppmd-stored` - logical and stored bytes classified as reserved PPMd
- `raw-storage-ratio-permille`, `zlib-storage-ratio-permille`, `zerorun-storage-ratio-permille` - per-codec stored/logical ratio
- `raw-stored-share-permille`, `zlib-stored-share-permille`, `zerorun-stored-share-permille` - per-codec share of stored payload bytes
- `unknown-codec-chunks` - chunks whose descriptor could not be classified

These fields are intended for diagnostics and benchmark reports. They are plain
text and remain easier to parse than human prose.
## `fp info --json`

`fp info <archive.fp> --json` prints the same diagnostic intent as text info,
but in a single JSON object. Automation should prefer this form when collecting
release metrics or comparing archives.

Example keys include `entries`, `size`, `totalStored`, `containerOverhead`,
`rawChunks`, `zlibChunks`, `zeroRunChunks`, `ppmdChunks`, and `payloadIntegrity`.
## `--compression auto`

`fp pack <input> <archive.fp> --compression auto` evaluates the currently
available V1 codecs per regular file and stores the smallest encoded payload.
The archive still records concrete chunk descriptors such as `raw` or `zlib`;
there is no `auto` codec in the file format.

With the current stored-block zlib profile, `auto` usually selects `raw` because
stored-block zlib adds framing overhead. This behavior is expected until a real
deflate compression profile is added.

`fp codecs` and `fp codecs --json` include the numeric compression method ID.
The ID is the stable format value, while the text name is the user-facing label.

## `--choose-smallest`

`fp pack <input> <archive.fp> --choose-smallest` evaluates raw and zlib for each
chunk and stores the smaller encoded payload. It is mutually exclusive with
adaptive selectors such as `--compression auto` and `--compression-profile`.
The archive still stores concrete codec descriptors per chunk.

### `fp codecs --available`

`fp codecs --available` is an explicit form of the default codec listing. It reports only codecs available in the current binary. Use `fp codecs --all` when reserved but unavailable codec ids must also be shown.

Examples:

```text
fp codecs --available
fp codecs --json --available
fp codecs --all
```

`--available` and `--all` are mutually exclusive.

### Compression method parsing

`--compression` now uses the same method-name parser as the SDK. Known reserved names such as `zstd` and `lz4` are recognized as method ids, but they still fail with `UnsupportedCodec` until their backend is compiled in and reported as available.

### Info codec counters

`fp info` and `fp info --json` report aggregate codec class counters in addition to method-specific counters. This is intended for CI dashboards and release validation before optional codec backends are enabled.

### Payload ratio fields

`fp info` reports `payload-savings` and `payload-storage-ratio-permille`. JSON output exposes the same values as `payloadSavings` and `payloadStorageRatioPermille`.

### Reserved codec chunk field

`fp info` reports `reserved-codec-chunks`; JSON output exposes `reservedCodecChunks`. The value is useful when archives contain method ids reserved by the format but unsupported by the current binary.

### Unsupported codec presence flag

`fp info` reports `unsupported-codec-present`; JSON output exposes `unsupportedCodecPresent`. This is the recommended release gate field when only a yes/no signal is needed.

### Codec support status field

`fp info` reports `codec-support-status`; JSON output exposes `codecSupportStatus`. Current values are `fully-supported`, `reserved-unsupported`, and `unknown-unsupported`.

### Codec migration and risk fields

`fp info` reports `codec-migration-needed` and `unknown-codec-risk`; JSON output exposes `codecMigrationNeeded` and `unknownCodecRisk`. Use these fields to distinguish planned reserved-codec rollout from unexpected unsupported codec evidence.

### Archive info release readiness fields

`fp info` reports `codec-ready`, `payload-efficiency-acceptable`, and `archive-info-release-gate`; JSON output exposes `codecReady`, `payloadEfficiencyAcceptable`, and `archiveInfoReleaseGate`. These are derived release gate helpers and do not replace the detailed counters.

### Archive info policy status field

`fp info` reports `archive-info-policy-status`; JSON output exposes `archiveInfoPolicyStatus`. Current values are `ready`, `payload-expansion`, `unsupported-codec`, and `payload-expansion-and-unsupported-codec`.

### Payload expansion fields

`fp info` reports `payload-expanded` and `payload-expansion-present`. JSON output exposes `payloadExpanded` and `payloadExpansionPresent`.

### Payload efficiency field

`fp info` reports `payload-efficiency`; JSON output exposes `payloadEfficiency`. Current values are `empty`, `neutral`, `saves-space`, and `expands`.

### Payload delta direction field

`fp info` reports `payload-delta-direction`; JSON output exposes `payloadDeltaDirection`. Current values are `none`, `saved`, and `expanded`.

### Archive size ratio fields

`fp info` reports `payload-archive-share-permille` and `container-overhead-ratio-permille`. JSON output exposes `payloadArchiveSharePermille` and `containerOverheadRatioPermille`.

`metadata-archive-share-permille` complements these fields by reporting the
combined metadata section share. JSON output exposes it as
`metadataArchiveSharePermille`.

### Payload density field

`fp info` reports `payload-density`; JSON output exposes `payloadDensity`. Current values are `empty`, `low`, `moderate`, and `high`.

### Container overhead class field

`fp info` reports `container-overhead-class`; JSON output exposes `containerOverheadClass`. Current values are `none`, `low`, `moderate`, and `high`.

### Archive layout profile field

`fp info` reports `layout-profile`; JSON output exposes `layoutProfile`. Current values are `empty`, `payload-dominated`, `balanced`, and `metadata-dominated`.

### Info payload delta magnitude

p info prints payload-delta-ratio-permille and payload-delta-magnitude. The JSON form exposes the same values as payloadDeltaRatioPermille and payloadDeltaMagnitude, so automation can separate tiny codec overhead from material payload changes.


### Info compression mix

p info prints compression-mix. The JSON form exposes the same classification as compressionMix, allowing dashboards to track stored-only, compressed-only, and mixed archives without re-deriving chunk counters.


### Info codec risk level

p info prints codec-risk-level. The JSON form exposes the same value as codecRiskLevel, allowing release automation to distinguish normal reserved-codec migration work from unknown codec risk.


### Info severity

p info prints rchive-info-severity. The JSON form exposes rchiveInfoSeverity, giving release scripts a single coarse status while preserving detailed policy and codec fields for diagnostics.


### Info storage outcome

p info prints storage-outcome. The JSON form exposes storageOutcome, giving dashboards a stable high-level payload storage verdict without reinterpreting savings, expansion, and ratio counters.


### Info compression adoption stage

p info prints compression-adoption-stage. The JSON form exposes compressionAdoptionStage, summarizing compression rollout state from chunk mix and codec risk counters.


### Info optional metadata profile

p info prints optional-metadata-profile. The JSON form exposes optionalMetadataProfile, summarizing optional metadata sections for release dashboards and compatibility reports.


### Info verification coverage

p info prints erification-coverage. The JSON form exposes erificationCoverage, allowing automation to track integrity and recovery coverage directly.


### Info release action

p info prints 
elease-action. The JSON form exposes 
eleaseAction, giving release scripts a direct policy action without losing the detailed status, severity, and codec-risk fields.

