CLI reference

The @putnami/cloud extension adds 20 commands under putnami cloud. putnami cloud --help lists them, together with the machine commands and the older names described at the end of this page. putnami cloud <command> help lists the verbs of one command. The Key flags column is selective: run putnami cloud <command> --help for every flag of the installed command. Commands that return records support --output=jsonl for scripts and agents.

Command What it covers
login, logout, whoami Your session on this machine
setup Link this repository to a workspace
status One line per entry below that has a status: ok, degraded, failing or unknown
token A bearer for a script, and workspace machine tokens
registries The npm, Go, OCI and put registries on this machine
packages Namespaces, read grants, public mirrors, image moves, archive publication
channels Move a channel, read it, or follow one
ci Hosted CI runs, recovery, and the putnami.ci.json contract
cache The remote build cache
source The GitHub repository linked to the workspace
config, secrets Project configuration and secrets
db Databases: access grants, a local bridge, migrations
env Environments: what runs where, prerequisites, convergence
deploy Show one release, or submit an operator release request
logs, traces, metrics Query a project's telemetry

Status

putnami cloud status prints one line per entry that has a status: its state, what it found, and the next command to run. The next command is the entry's fix when the entry is not ok and names one, else the command that shows the entry in full. For example, 7 of the 12 lines:

STATE     ENTRY       DETAIL                                                              NEXT
ok        whoami      you@example.com, workspace ws-acme                                  putnami cloud whoami
ok        registries  npm, go, oci on demand; put key active                              putnami cloud registries status
degraded  packages    npm, go not needed; oci not bound; put bound                        putnami cloud packages status
ok        ci          9 of 9 checks healthy; 439 runs, ~€8.79 in 7 days                   putnami cloud ci status
ok        config      12 projects, every required key set, 40 optional missing            putnami cloud config status
degraded  db          4 databases, 18 bindings ready, 1 not bound by a selected workload  putnami cloud db status
failing   env         prod: 11 of 12 workloads ready, canary gen 315                      putnami cloud deploy status cm_721cd93a

The 12 entries are whoami, token, registries, packages, channels, ci, cache, source, config, secrets, db and env. Each line is the header of that entry's own status command, described in Status of each entry.

The command reads the entries in parallel and covers the whole workspace, wherever you run it. An entry whose read fails, or that does not answer within 15 seconds, reads unknown with the reason, and every other line still prints. Until you are signed in and the repository is linked, every line except whoami and registries reads unknown. The env line covers every environment putnami.ci.json declares; --env <env> limits it to one.

The command exits 1 when an entry is failing, and 0 otherwise. With --strict, it also exits 1 when an entry is degraded or unknown: use that form to gate CI. With --output=json, data is {state, entries}: state is the worst entry, and entries holds the full node of each entry, metrics and checks included.

The deployment table that putnami cloud status printed before is putnami cloud env status --health or putnami cloud env status --provenance.

Status of each entry

Every entry that has a state has its own status command:

putnami cloud <entry> status [<name>] [--strict] [--output=json]

<name>, where the table below shows it, narrows the status to one item, such as one project for config status or one database for db status. putnami cloud whoami takes no status verb: it is its own status. putnami cloud deploy status <release-id> and putnami cloud env doctor [<env>] print the same shape.

The output starts with a header line: the title, the state, and what the entry found. A table of metrics follows, then a table of checks. A check that is not ok prints its fix under it. When the entry is not ok and no check names a fix, a last line next: <command> names the entry's own fix:

packages  degraded  npm, go not needed; oci not bound; put bound

  METRIC           VALUE  WINDOW
  bindings active  1      now

  STATE     CHECK  DETAIL
  ok        npm    not needed
  ok        go     not needed
  degraded  oci    not bound; putnami.ci.json declares environments
                   fix: putnami cloud packages namespaces activate --protocol oci --namespace acme --idempotency-key acme-oci
  ok        put    namespace acme

Every status uses the same 4 states:

State Means
ok What is declared exists and works.
degraded The entry works, with a gap that needs attention.
failing The entry does not work.
unknown The entry did not answer, or a check could not run.

An entry takes the state of its worst check. From best to worst, the order is ok, degraded, unknown, failing.

Every status command exits by the same rule:

  • It exits 1 when the state is failing, and 0 otherwise.
  • With --strict, it also exits 1 when the state is degraded or unknown.
  • A failing status also prints <title> is <state>: <detail> on standard error.
  • A command that cannot start still exits with its own code: 2 for a usage error, 3 for a session the service refuses.

With --output=json, the command prints one result envelope, and its data is the node, on success and on failure alike. A node has these fields; an empty field is left out:

Field Holds
id A stable id for scripts, such as ci or ci.runner
title The name a person reads
state ok, degraded, failing or unknown
detail What the check found
fix The command that clears a state other than ok, when one exists
metrics The measured values, described below
facts The identifiers a script reads and detail only quotes, such as an image digest or a run id
children The checks the state comes from, each a node of the same shape

A metric has an id, a title, a value and a unit: count, bytes, percent, seconds or eur. limit is the total or the quota the value reads against, when one applies. window is the period a counted value covers, such as 7 days or last run; without it, the value is measured now. estimated is true for a value computed from rates instead of measured. kind is usage or health:

  • A usage metric is a quantity the workspace consumes, the kind a bill or a quota reads: runs, spend, keys set.
  • A health metric measures how well the entry works: queued runs, ready workloads, cache reuse.

The data of putnami cloud registries status --output=json, trimmed:

{
  "id": "registries",
  "title": "registries",
  "state": "ok",
  "detail": "npm, go, oci on demand; put key active",
  "metrics": [
    {"id": "registries_configured", "title": "registries configured", "value": 4, "unit": "count", "limit": 4, "kind": "health"}
  ],
  "children": [
    {"id": "registries.npm", "title": "npm", "state": "ok", "detail": "on demand, npm.putnami.dev"}
  ]
}

Read one value with jq:

putnami cloud ci status --output=json | jq '.data.metrics[] | select(.id=="queued_runs") | .value'
Command Checks Usage metrics Health metrics Fails when
whoami The session on this machine, and the workspace this repository is linked to session expires in You are not signed in, or the repository is not linked
token status Each workspace machine token that is not revoked active machine tokens machine tokens expiring within 7 days Never. A token past its expiry, or expiring within 7 days, is degraded
registries status [<registry>] Each registry endpoint on this machine, and the state of its stored key registries configured A stored key is revoked or expired
packages status [<protocol>] The npm, go, oci and put namespace bindings this checkout needs. Without an oci binding, oci is ok when another workspace granted yours at least one active OCI publisher package share bindings active Never. A needed binding that is missing is degraded
channels status [<channel>] Each channel putnami.ci.json declares, and the generation each registry applied channels declared registries behind A registry is still behind at the --wait deadline
ci status Each CI readiness check, including the open pull request heads that have no run, then the dispatch, the live run and the last run as facts runs, spend (7 days) queued runs, stuck runs, oldest queued, undelivered checks, reused tasks (last run) A run is stuck, the runner is stale, or check results wait to be published. A pull request head that has no run, other than a draft's, is degraded
cache status .putnami/cache.json, and the identity its token source signs in as reused tasks, served from cache, executed (last run) Never
source status The connected GitHub repository, its GitHub App installation, and the App's permissions open pull requests stale pull requests, with no update in 14 days The installation is suspended or removed, or the repository left it
config status [<project>] Each project's declared config keys against what each environment resolves projects, keys declared, keys set required missing, optional missing A required key has no value and no default
secrets status [<project>] Each project's declared secrets, set or not. It never reads a value secrets set required missing, optional missing A required secret is not set
db status [<db>] Each database, the workloads putnami.ci.json selects that bind it, and each binding that is not ready databases, schemas; with <db> and an active grant, size and tables bindings ready, databases not bound; with <db> and an active grant, connections Never. A binding that is not ready, or a database no selected workload binds, is degraded
env status [<env>] Each environment putnami.ci.json declares: the newest move of its channel, and each workload declared or deployed workloads declared workloads ready, workloads not deployed, workloads not declared, CD generation A workload failed, or ended partial or skipped

config status and secrets status without a project stop after 240 service calls, so that putnami cloud status answers in time. The projects past that budget form one unknown check named not read; run the status of each one by name. The config apps whose name no project of the checkout has, such as the old name of a renamed project, form one degraded check named no project. Their keys do not count. An app that a service account reads through an active secret grant, such as a shared GitHub App key, is not in that check: the fact shared_apps names it. The status reads the grants only when an app has no project. Listing them needs platform.workspace.manage; when the list is refused, the no project check is unknown, because a shared app may be in it.

putnami cloud config status shop/workloads/api lists, under each environment, each key that has no value and no default:

config shop/workloads/api  failing  1 required key missing

  METRIC            VALUE           WINDOW
  keys declared     12              now
  keys set          11 of 12 (92%)  now
  required missing  1               now
  optional missing  0               now

  STATE    CHECK              DETAIL
  failing  prod               1 required key missing: stripe.endpoint
                              fix: putnami cloud config publish shop/workloads/api --env prod
  failing    stripe.endpoint  required, no value and no default

A key that resolves to its schema default counts as set. The fix is config publish, which writes the values your committed conf/env*.yaml files hold.

putnami cloud secrets status shop/workloads/api lists each secret that is not set, with the command that sets it from standard input:

secrets shop/workloads/api  failing  1 required secret missing in prod

  METRIC            VALUE         WINDOW
  secrets set       2 of 3 (67%)  now
  required missing  1             now
  optional missing  0             now

  STATE    CHECK             DETAIL
  failing  prod              1 required secret missing: stripe.api_key
  failing    stripe.api_key  required, not set
                             fix: putnami cloud secrets set shop/workloads/api stripe.api_key --env prod --from-stdin

putnami cloud db status <db> shows one database. It never opens a grant: the size, tables and connections show only while you hold an active grant on the database. Without one, a metrics check names the db grant request command.

db shop_orders  ok  postgres, 2 schemas, bound by 2 workloads, your read grant active

  METRIC       VALUE    WINDOW
  size         212 MiB  now
  tables       38       now
  connections  4        now

  STATE  CHECK                  DETAIL
  ok     schemas                2 schemas: migration, orders
  ok     shop/workloads/api     binds it as orders in prod
  ok     shop/workloads/worker  binds it as orders in prod
  ok     grant                  your read grant is active until 2026-10-04T12:00:00Z

Deploy and release

A merge to main publishes a release set and moves a channel. The platform then deploys every environment that follows that channel. See Environments follow channels.

Command Does Key flags
putnami publish Build and publish selected project artifacts, config, migrations, archives, deployment declarations, and site-content members --env, --archives, --namespace, --dry-run, --skip-publish-config, --skip-publish-migration, --skip-publish-deployment
putnami cloud deploy status <release-id> Show one release as a status: one check per workload. Exits 1 when the release failed or ended partial or skipped; a release still converging reads degraded --strict, --output=json
putnami cloud deploy publish-v2 --request-file <path> Needs the workspace deploy permission. Submit an exact release set to one environment for the projects the request names. To roll one project back, name an older release set --request-file, --wait
putnami cloud env status [<env>] Show each environment putnami.ci.json declares, or the one you name, against what it runs: its channel and each workload. --health and --provenance print the deployment table instead --env, --workspace, --strict, --provenance, --health, --output=json
putnami cloud env doctor [<env>] Check every prerequisite continuous delivery (CD) needs for one environment and print the fix for each one that is not met. Read-only; exits 1 when a prerequisite is missing, which reads failing. A check that could not run reads unknown and fails the command only with --strict --env, --strict, --workspace, --output=json
putnami cloud env enable [<env>] Apply every workspace-owned prerequisite of one environment (namespace bindings, environment definition, Runtime grants), report the operator-only rows with their fix, then print the doctor table. A second run on the same commit writes nothing; exits 1 when a step failed or a row is still missing --env, --source-revision, --workspace, --output=json

putnami cloud env status covers every environment putnami.ci.json declares, then every other environment where the workspace runs a workload. Under each environment, it checks the channel the environment follows, each workload putnami.ci.json declares, and each workload that runs there without a declaration. This sample leaves out the 11 workloads that read ok:

env  failing  prod: 11 of 12 workloads ready, canary gen 315

  METRIC                  VALUE           WINDOW
  workloads declared      12              now
  workloads ready         11 of 12 (92%)  now
  workloads not deployed  0               now
  workloads not declared  0               now
  prod CD generation      315             now

  STATE    CHECK                 DETAIL
  failing  prod                  11 of 12 workloads ready, canary gen 315
  ok         channel canary      gen 315 opened 2026-10-04T08:18Z (rs_8fa9d34e…), release cm_721cd93a
  failing    shop/workloads/web  failed, revision web-00041: image pull refused
                                 fix: putnami cloud deploy status cm_721cd93a

A workload that is ready reads ok. These read degraded:

  • A workload still deploying.
  • A workload that serves, but whose last run failed.
  • A workload declared and not deployed.
  • A workload deployed and not declared.

A workload that failed, or whose release ended partial or skipped, reads failing, and the command exits 1.

With --output=json, data is the status node. --health and --provenance keep the deployment JSON: workspace_id, deployments, channel_follow, and with --health, health. A script that reads deployments passes one of them.

putnami cloud env status --health and --provenance read the environment you name, else the environment .putnami/cloud-link.json records, else prod.

--health prints the deployment table: one row per project and environment, with its serving revision, its health, and its last run. --provenance prints the provenance table instead. Both start with one CD line for the environment they read. The line names every channel the environment follows and what the newest move of that channel did:

CD prod ← canary: gen 42 converged 2026-09-18T10:02Z (rs_ab12cd34…)

A move that deployed nothing or only part of the environment also shows its reason, and a move Control is still delivering reads in flight. When the header cannot be read, the line reads CD prod: unavailable (<reason>) and the table still prints. Structured output carries the same data under channel_follow.

The LAST RUN, TRIGGER, and REASON columns describe each project's most recent run in its environment, failed runs included, while HEALTH keeps describing the last successful release. They are read from the 100 most recent runs of each environment; a project whose last run is older shows -. TRIGGER reads cli for a run no channel move opened, and unknown when Control could not read its channel-move records.

The release and commit of a row describe the last deploy that made the project serve, whether a channel move or an operator request opened it. The revision and deploy time describe that deploy too, unless a config write rolled a newer revision since: the row then shows that revision and when it rolled. A deploy that failed after its revision took the traffic counts as the last deploy, and STATE shows the failure.

A deploy that a channel move opened is read from the same 100 most recent runs: a project whose last such deploy is older shows its last deploy that no channel move opened instead. CONFIG VERSION reads - for a deploy that a channel move opened, because that deploy pins no config version.

putnami cloud env status --provenance prints one row per project: PROJECT, COMMIT, TREE, RELEASE, REVISION, and CONFIG VERSION. COMMIT and TREE show the first 7 characters. TREE is the git tree of the commit's content, recorded by the channel move that opened the project's last run. It shows only when that run deployed the commit in COMMIT, so the two always describe the same source. It reads - when the run was on another commit, when no channel move opened the run, or when the move carried no tree. Structured output carries the full tree as trigger.source_tree.

putnami cloud env status prod --health answers "is prod on main and healthy". It adds three columns to the rows of the --env environment. Rows of other environments show - in them.

Column Shows
ERRORS (10m) The number of log entries at severity ERROR or above in the last 10 minutes
TOP ERROR The most frequent of those messages: the message or msg field of a JSON entry, else the text, cut to its first line
ON MAIN yes, no, or unknown: whether the served commit is on main in your local checkout

The errors come from one logs read for the whole environment, not one read per service. The read stops after three pages of up to 1,000 entries each. When more entries remain, every count is a lower bound: the cell reads N+ (for example 12+), a note line above the table says so, and structured output sets health.logs.capped. Entries with no service label, or with a label that matches no row, are counted in a note line and never added to a row. When the logs cannot be read (a machine token, which cannot read logs, an older control plane, or a backend error), the note reads Errors prod: unavailable (<reason>), the error cells show -, and the command still succeeds.

ON MAIN compares the served commit with origin/main, or main when origin/main does not exist, in your local checkout. It never fetches, so run git fetch first for a current answer. It reads yes when the commit is on main and no when your checkout has the commit and it is not on main. A pull request head that was squash-merged reads no: that exact commit is not on main. It reads unknown when no commit is recorded, the directory is not a git checkout, there is no main ref, or your checkout does not have the commit. Structured output carries every field, including the reason for each unknown, under the health key; without --health that key is absent.

putnami cloud env doctor prints the status of one environment's prerequisites, with one check per prerequisite. A prerequisite that is met reads ok. One that is missing reads failing, with its fix. One that could not be checked reads unknown, as every server check does when the control plane does not answer. The command exits 1 when a prerequisite is missing; with --strict it also exits 1 on an unknown check, which is the form to use as a CI gate. Before the first deploy lists the checks and the ones that can read unknown.

putnami cloud env enable applies every fix the workspace owns among those prerequisites and reports the rest, then prints the prerequisites as a table: ok, missing or unknown on each row. Each write reads the current revision first and sends it as the expected revision, so a second run writes nothing. It needs platform.workspace.manage; a session without it is refused before any write. Enable the environment in one command lists what each row gets.

Identity and workspace

Command Does Key flags
putnami cloud login Sign in with OAuth device authorization --no-open, --client-id, --scope
putnami cloud logout Clear local Cloud credentials and revoke reachable registry tokens
putnami cloud whoami Show the account signed in on this machine and the workspace the repository is linked to. Exits 1 when either is missing --strict, --output=json
putnami cloud setup Link the repository to a workspace. With no linked workspace, create one; --slug chooses its slug --workspace, --workspace-name, --slug, --environment, --no-cache, --auto
putnami intelligence setup Enable Intelligence, install its agent wiring, and report discovered hosted Intelligence availability --disable, --graph
putnami cloud token [<target>] Mint a workspace bearer for a script, or a bearer for one target cache, npm, go, oci or put (or --for <target>), --materialize
putnami cloud token create|list|revoke Create, list, or revoke workspace-owned machine tokens --name, --scopes
putnami cloud token status Check each machine token of the workspace that is not revoked. One past its expiry, or expiring within 7 days, reads degraded --strict, --output=json
putnami cloud source Connect, inspect, or disconnect the workspace GitHub repository. status checks the connection, the GitHub App installation, and its permissions connect, status, disconnect

Hosted CI and channels

Command Does Key flags
putnami cloud ci Enable the subscription; inspect, start, cancel, retry, and diagnose runs; operate recovery modes enable|disable|subscription, list|view|logs, start|cancel|retry, status|usage|insights|timings, repair|pause|drain|resume
putnami cloud ci report Submit a delivery-run conclusion for the current pushed commit --conclusion, --exit-code, or -- <cmd…>; optional --status
putnami cloud ci init|validate|fmt|explain Write, check, format, or explain putnami.ci.json init --force, fmt --check, explain --event push|tag|pull_request --branch <b>|--git-tag <t> [--pr <n>]
putnami cloud channels set <channel> Point a channel at a release set that already exists: promotion and rollback --from <channel|rs_id>, --expected <rs_id>
putnami cloud channels status [<channel>] Show the head of a channel and the generation each registry applied; without a name, every channel putnami.ci.json declares --wait <duration>, --strict, --output=json
putnami cloud channels follow <namespace> <channel|rs_id> Make the workspace's CI follow a producer channel, or pin one release set, optionally changing the runner channel at the same time --runner-channel

Run IDs may be shortened to any unambiguous prefix. CI mutations require --reason; pass --yes as well in a non-interactive environment. See Hosted CI for the setup and recovery path.

putnami cloud ci init writes a putnami.ci.json that runs the lint, test, build and validate jobs your extensions declare, and nothing else: no publication and no environment. validate checks the file against its schema and against the jobs your extensions declare. fmt rewrites it in canonical form, and fmt --check only reports. explain shows which rule an event matches and what the run would publish, without calling the provider.

putnami cloud channels set moves a channel only if its head is still the one the command read, so a concurrent move makes it fail instead of being lost. putnami cloud channels status reads degraded while a registry is behind, and exits 0: registries apply a move a few seconds after it. --wait 5m polls until every registry serves the head. A registry still behind when the time runs out reads failing, and the command exits 1.

Configuration and data access

Command Does Key flags
putnami cloud config status [<project>] Check each project's declared config keys against what each environment resolves. Exits 1 when a required key has no value and no default --strict, --output=json
putnami cloud config show [<project>] Show the resolved config, or one view of it --declared, --schema, --key, --secret-keys, --reveal-secrets, --keys, --metadata, --env, --with-secrets
putnami cloud config validate [<project>] Validate local authored Config inputs without packaging or network access --env, --schema-from, --namespace
putnami cloud config drift <project> Compare the committed conf/env*.yaml with the published config; exits non-zero on drift
putnami cloud config put <project> Force-write non-secret values from a YAML file --config-from
putnami cloud secrets status [<project>] Check each project's declared secrets in each environment. Never reads a value. Exits 1 when a required secret is not set --strict, --output=json
putnami cloud secrets Manage workspace and project secrets --block, --field, --from-stdin, --from-file, --reveal, --yes
putnami cloud db status [<db>] Check each database against the workloads putnami.ci.json selects. Never opens a grant --strict, --output=json
putnami cloud db Inspect databases, manage time-boxed access, or open a local bridge list, info <db>, grant request|list|revoke, connect, --database, --level, --reason, --ttl

Observability and delivery evidence

Command Does Key flags
putnami cloud logs Query or live-tail application logs --app, --since, --level, --follow, --cursor
putnami cloud metrics Query application metric series --app, --window, --from, --to, --cursor
putnami cloud traces Query traces and filter slow requests --app, --slow, --from, --to, --cursor
putnami intelligence audit-attest Get, set, or batch-prefetch immutable Intelligence audit attestations get|set|prefetch, --repo, --project, --group, --input-hash, --rubric-hash
putnami intelligence provenance Record or list signed provenance receipts: which agent run took part in a commit record|show, --commit, --repository, --family, --model, --run, --run-kind
putnami intelligence review Manage workspace subscription reviews, owner credentials, and workers doctor|status|launch|pause|resume|reconcile|cancel, auth, worker

putnami intelligence provenance record records one receipt for one commit, HEAD by default. A review labels its independence: how sure the service is that the reviewer model differs from the author models. The label is full only when every commit of the reviewed branch holds a verified receipt. One commit without a receipt lowers it to partial. Record a receipt for every commit of the branch:

for c in $(git rev-list <base>..HEAD); do putnami intelligence provenance record --family <family> --model <model-id> --commit "$c"; done

The complete intelligence review command families are:

Family Verbs
Review control doctor, status, launch, pause, resume, reconcile, cancel
Owner credentials auth login, auth replace, auth status, auth revoke for codex or claude-code
Review workers worker enroll, worker list, worker revoke, worker run

Registries, packages and cache

Command Does Key flags
putnami cloud registries Configure registry endpoints, check them and their stored keys, or revoke legacy credentials setup, status [<registry>] (also the default), logout, optional --registry
putnami cloud packages status [<protocol>] Check that the linked workspace binds each npm, go, oci and put namespace this checkout needs, or publishes its OCI images through package shares another workspace granted it --strict, --output=json
putnami cloud packages namespaces|grants|mirrors Manage namespace bindings, read grants, and public mirror targets namespaces activate|list, grants create|list|revoke, mirrors add|list|remove|rotate-credential; mirrors add takes --ecosystem npm|oci|archive, --id, --destination, optional --alias, and --package for archive
putnami cloud packages copy|retag|revert Copy, retag, or revert OCI images server-side copy <src> <dst>, retag <ref> <tag…>, revert <repo>:<channel>
putnami cloud cache Check or disable the remote build cache. status also shows how many tasks the last CI run took from the cache status (also the default), disable, optional --remove

Direct publishers

putnami publish runs these for you. Run one directly to publish a single input again.

Command Does Key flags
putnami cloud config publish Register an app schema and publish conf/env.<env>.yaml --app, --env, --dry-run
putnami cloud db migrations publish Publish a workload migration bundle --app, --bundle-from, --namespace, --bundle-version, --dry-run
putnami cloud packages publish Publish pre-built extension archives as one immutable Put version --app, --archives-from, --binary-name, --dry-run

Machine commands

These commands serve the engine, publication and image packaging. Prefer putnami publish and putnami package for the normal project workflow.

Command Does Key flags
putnami cloud release-set Serve exact immutable release-set provider operations from a private request document resolve|release|channel-set|channel-status, --request-file <absolute-mode-0600-file>
putnami cloud image-layers Produce or verify the deterministic tarballs declared by an image project's image-layers.json --project, --check
putnami cloud registry-token Mint your registry bearer for one known host --host, --materialize

Older command names

The names below still run. Use the new form in scripts and docs.

Older form Use instead
putnami cloud status for the deployment table putnami cloud env status --health or putnami cloud env status --provenance
putnami cloud tokens create|list|revoke putnami cloud token create|list|revoke
putnami cloud distribution bindings … putnami cloud packages namespaces …
putnami cloud distribution grants|mirrors … putnami cloud packages grants|mirrors …
putnami cloud oci copy|retag|revert putnami cloud packages copy|retag|revert
putnami cloud publish-archives putnami cloud packages publish
putnami cloud track putnami cloud channels follow
putnami cloud report putnami cloud ci report
putnami cloud validate-config putnami cloud config validate
putnami cloud publish-config putnami cloud config publish
putnami cloud publish-migration putnami cloud db migrations publish
putnami cloud config <project>, config list, config resolve putnami cloud config show <project>, show --keys, show --metadata
putnami channel set|status putnami cloud channels set|status
putnami ci init|validate|fmt|explain putnami cloud ci init|validate|fmt|explain

putnami cloud status now prints the one-line summary, and refuses --health and --provenance with exit 2. A script that parsed its deployment table must call putnami cloud env status --health or putnami cloud env status --provenance. Plain putnami cloud env status prints the status node.

Next