Hosted CI
Connect a repository and enable its workspace subscription to run the declared
putnami.ci.json pipeline on pushes and pull requests.
Hosted CI owns verification and publication. Continuous deployment starts after an accepted publication moves a channel; the environment follows that channel independently.
To run Putnami in another CI service or in an agent session, see
Agent and CI environments. A job there
with no signed-in user sends PUTNAMI_CLOUD_TOKEN to the build cache, whatever
its scopes. A token without cache.read is refused on every run. Give that
token cache.read, or set PUTNAMI_CACHE_TOKEN to a separate cache.read
token, which then wins.
Connect and enable
Link the GitHub repository, then enable CI for the current Cloud workspace:
putnami cloud source connect --repo <owner>/<repo>
putnami cloud ci enable
putnami cloud ci subscription --output=jsonNew subscriptions use the canary runner channel. To hold the runner on the
stable channel explicitly, run putnami cloud ci enable --runner-channel stable.
ci disable revokes admission without deploying or deleting a service.
Declare the pipeline
The root putnami.ci.json names the commands, common flags, runner selection,
publication channels, and trigger rules. A minimal main-and-pull-request shape
is:
{
"$schema": "https://putnami.dev/schemas/putnami-ci.json",
"version": 3,
"commands": ["lint", "test", "build", "validate"],
"runner": { "selection": "impacted", "timeoutMinutes": 45 },
"rules": [
{ "pullRequests": true, "publish": ["pr-{number}"], "baseline": "canary" },
{ "branches": "main", "publish": ["canary"] }
]
}A start or a push of another branch, with no pull request, at a commit the
default branch already ran opens no run and answers the default branch's
newest run of that commit. The exception is a branch whose own rule
publishes: it gets its own run, so its channels still move. A pull request
and a tag always get their own run. While the default branch's run of the
commit is still opening, ci start opens nothing and asks you to retry in
10 seconds.
Publication creates immutable release-set members and advances only the
channels selected by the matching rule. Add envs when an environment should
deploy itself after one of those channels advances.
Measure a pull request's first publication against a baseline
A member is one artifact a publication releases, such as an image or a package. A channel is a named pointer to the latest published set of members, its head.
A pull request's pr-{number} channel has no head before its first
publishing run. Without a baseline, that run publishes every member of the
workspace. baseline names an existing channel to compare with instead, here
canary: the first run publishes only the members whose inputs differ from
the members in the head of canary. Putnami CI passes that channel to the CLI
as --baseline-channel. The run reads the baseline channel and never moves
it.
baseline applies only to a publishing branch or pull-request run that
selects the impacted projects. A run with "selection": "all", a tag run, and
a run that checks every project because it found no earlier commit to compare
with ignore it.
The proposed squash message
On a pull request run, Putnami CI sets PUTNAMI_PROPOSAL_MESSAGE to the pull
request title, followed by a blank line and the body. When Putnami can read the
repository's squash setting and it squashes without the body, the variable
holds the title alone, which is stricter than GitHub's own squash message.
Only the blocking commands
receive the variable. The @putnami/sdd extension reads it to check that the
message keeps every breaking change the commits declare.
If you push before you open the pull request, opening it starts a new run of the same commit that receives the variable. That run replaces the push's run.
Putnami CI sets the variable only when the run selects the impacted projects
("selection": "impacted", the default). A run that selects every project has
no baseline to read the commits from, so its log says the message was dropped,
and the variable is not set. A message longer than 48000 bytes is not set
either: the run log states its size.
When the workspace declares @putnami/sdd, by name or by a workspace path such
as /tooling/sdd-extension, the run completes the history of the pull
request's commits. When you edit the title or the body, Putnami CI runs the
checks again on the same head.
Read a run
putnami cloud ci list
putnami cloud ci view <run>
putnami cloud ci logs <run> --level error
putnami cloud ci logs <run> --follow
putnami cloud ci statuslist sends its filters to the control plane, which applies the ones it
supports. The CLI applies the rest itself, such as --pr 0. Run IDs accept
an unambiguous prefix; the control plane looks the prefix up in one request.
view summarizes phases and failed tasks; logs carries the detailed
stream. For performance and cost evidence, use ci usage,
ci insights <run>, and ci timings <run>. For test, coverage and lint
findings, use ci results <run>.
The log is the stream of events the run's tasks report. Each line a task prints
reads <project:task> <message>. With --follow, a line appears within a few
seconds of the task printing it. --raw prints the stored records unchanged.
Read the pull request comment
Putnami keeps one comment on each open pull request from your repository, and
edits it in place each time the Putnami Verdict check of the pull request's
newest run completes with something new to say. The comment says the verdict,
the proof diff's counts, what waits for whom, the approvals given and the gaps
a person accepted, and links to the change in putnami.app. The Details link
of the check opens the same change page.
- Only the newest run on the pull request's head writes the comment. A push to a branch, a fork's pull request and a closed or merged pull request get none.
- Putnami does not write the comment exactly once, and GitHub does not order its writes. When an older run on the same commit writes late, the newest run writes its comment again. A late write from a run on an older commit stays until the newer run's check completes again.
- A comment Putnami could not write is written later with no push or click: after a GitHub error, a restart of Putnami, or a push GitHub told Putnami about late. Putnami tries again within about 10 minutes, then less often, down to once an hour.
- Putnami edits only the comment its own GitHub App wrote. It never edits a comment a person or another App wrote.
- A pull request with more than 1,000 comments, none of them Putnami's, gets no new comment.
- The comment needs the GitHub App's write permission on pull requests.
Read what a change proved and lost
The Putnami Verdict check leads with the proof diff: each requirement of
your run compared with main at the commit your change is built on. It counts
the requirements the change newly proved, the ones it lost, and the new ones
it does not prove yet, then lists each one, the lost first, at most 50.
| Change | On main |
In your run |
|---|---|---|
| newly proven | not verified, or absent | verified |
| lost | verified | contradicted, missing, stale, unmapped or unexecutable |
| new, not proven | absent | not verified |
- A proof your run did not read is neither lost nor new: no test of it ran, and the cache held no report.
- A lost requirement blocks the merge until a person accepts it, and the acceptance holds for that commit only. An earlier acceptance of the same requirement does not cover it, and a new push asks again.
- A lost requirement of a project your change only reaches, or one the verdict holds no gap of, blocks nothing. The check still lists it, as "Lost, for information", and the counts say how many, such as "2 lost, 1 of them for information".
- Putnami compares with
mainat the base of your change, or else at the commit your run measured the change from, such as the merge base of its green baseline. - When Putnami holds no state of
mainat those commits, the check says the proof diff is unknown. Any unproven requirement may then be a lost proof: a person accepts it for that commit only, never for the whole repository, and the check says "Accepted for this commit by …". - When Putnami cannot read the proof diff of a verdict with no gap, the check still passes, and says it reads the diff again at the next publish.
- The gaps that wait come first. The accepted gaps fold below them.
GET /v1/workspaces/{workspace}/runs/{run}/verdict/proof-diff serves the same
diff as JSON, with the base commit, the counts, and each requirement's gap:
who accepted it, whether an acceptance holds for the commit (head) or the
repository (repository), and whether a person can accept it. It needs
delivery.run.read on the workspace.
Read the cost
ci usage prints two costs for the window, 168h by default:
- Spend is an estimate: the measured machine time of each run times a fixed hourly rate. It is there as soon as a run ends.
- Billed cost is what the cloud provider charged, net of credits, in EUR. It has one line per UTC day, newest first, with the day's dispatched runs, the cost per run and the total. Read the trend from the per-run column.
putnami cloud ci usage --window 72hBilled cost (EUR, net of credits, per UTC day; the newest day can still grow):
day runs per run total
2026-10-09 40 0.31 12.42
2026-10-08 30 0.24 7.18
2026-10-07 10 0.29 2.90
all days 80 0.28 22.50
compute=10.50 egress=5.30 cache=2.00 logs=0.50 gateway=4.20 (upper bound: it also serves the console and the APIs)The all days line adds up the listed days. The last line splits that total
into five parts:
| Part | What it is |
|---|---|
compute |
The CI machines: cores, memory and disks. |
egress |
The network traffic the CI machines sent. |
cache |
Your share of the build cache: its operations and its storage. |
logs |
Your share of the run logs: their operations and their storage. |
gateway |
Your share of the gateway traffic. |
compute and egress are the cost of your own machines. The build cache,
the run logs and the gateway are shared, so each workspace takes a share
equal to its share of the day's dispatched runs. The cache and logs
figures pay for operations, which are the reads and writes, as well as for
stored bytes.
Three limits apply:
- The gateway figure is an upper bound. The gateway also serves the console and the APIs, and their traffic is in the same bill line.
- The newest day can still grow. The provider reports a day's cost over about three days, and Putnami reads it once a day.
- Days are UTC days, from the day the window starts in to yesterday. The
default 7-day window lists seven days, and
--window 24hlists yesterday. Each day is listed whole, with its own run count, so the first day starts before the window does. Today is not listed.
A day with no dispatched run shows - as its cost per run. When the answer
holds no billed day, the section is replaced by the line
billed cost: not available for this window. That is the case when no day is
stored yet for the window, and when the window starts today. With
--output=json, the same figures are under billed.
Read the merge outcome
ci usage --output=json also answers efficacy: what happened to the pull
requests merged into your repository's default branch, per UTC day, over the
same days as billed. Putnami computes each figure of a day once, at 06:00
UTC, from the second morning after it, so that a merge Putnami learns late
still counts. A figure whose facts are not complete waits for a later
morning, up to the seventh morning after the day.
| Field | What it is |
|---|---|
mergedPullRequests |
The pull requests merged that day. |
revertRate |
The share of them that revert an earlier pull request. |
fixShare |
The share of them whose title has the Conventional Commits type fix. |
strictPairRate |
Strict pairs per merged pull request. A strict pair is a fix merged that day that changes production code, and an earlier pull request, merged at most 14 days before it, that the fix reverts or cites next to a word such as "regression". |
medianDaysToFix |
The median time from the earlier pull request to its fix, in days. |
linksUnavailable |
The pull requests merged that day whose links Putnami cannot read: GitHub refuses the pull request or its changed files for good (404, 410 or 451), or it cites too many earlier ones. A 403 is not a refusal for good: Putnami tries again later. Each counts as having no links, so a high count means strictPairRate reads low. |
withoutGreenGateRate |
The share of them merged without a green gate: the latest hosted CI run on the head commit that finished before the merge did not succeed, or there was none. |
escapes |
For the pull requests merged 14 days earlier: how many a later strict pair named, split between those merged after a green gate and the others. Here a green gate is a hosted run or an uploaded local gate session. Each part has medianSize, the median of added plus deleted lines. |
A rate is null when no pull request merged that day. totals sums the
listed days. Five limits apply:
- A day appears only once Putnami has the merge facts of every pull request merged that day. Putnami completes the missing facts of the merges it reads, also of a merge from before Putnami recorded them. A day still missing facts on the seventh morning after it never appears.
escapesneeds the facts of every pull request merged from 14 days before the day to the day. Putnami computes it apart from the day's other figures: the day appears as soon as its own facts are complete, withescapesset tonulluntil the escape facts are complete too. Putnami waits for them until the seventh morning after the day. If they are still missing then,escapesstaysnull.- A pull request whose size Putnami does not know, with no added, deleted or
changed file recorded, counts in
escapesbut not inmedianSize.medianSizeisnullwhen no pull request of the part has a known size. withoutGreenGateRatecounts only hosted CI runs.escapesalso counts a local gate session you uploaded; see Upload local gate sessions.- The section covers one repository: the one connected to the workspace.
Without a computed day,
efficacyis absent. When Putnami cannot read the computed days,efficacyis absent too andefficacyUnavailableistrue.
Read the week's merges and deploys
GET /v1/workspaces/{workspace}/ci/usage counts the merges and the deploys of
its window, 7 days by default:
| Member | What it is |
|---|---|
merges.merged |
The pull requests merged into your repository. |
merges.neededPerson |
The merged pull requests that Putnami marked checked, because a person decided on their gaps, or whose head commit holds an approval of a declaration change. |
deploys.opened |
The deployment runs that started, in every environment. |
Each pull request counts with the newest hosted CI run on its head commit, never with the run on the merge commit. Three limits apply:
- Putnami counts the merges it recorded from 2026-10-14 at 21:00 UTC. A window that starts earlier can miss merges.
- A merge into any branch counts, not only into the default branch.
- Putnami reads at most the 1,000 newest merges of the window.
Add only=merges,deploys to get those two members alone, without the scan of
the runs. merges.verdicts splits the merges by the level of that run:
verified, checked, the answer of a verdict that did not pass, canceled
for a run still running at the merge or one that ended canceled without a
verdict, or none when the head has no run or no verdict. merges.lowerBound
is true when a count can miss merges. deploys.days has one entry per UTC day of the window. When
Putnami cannot read a part, it is absent and mergesUnavailable or
deploysUnavailable is true. putnami cloud ci usage does not print them
yet.
Read your features and their gaps
Live › Features on putnami.app lists the features your repository declares,
grouped by domain. Features with requirements no test proves come first, and
the fully proven ones fold into one count. A feature's page shows its spec's
outcomes, non-goals and decisions, its unproven requirements, the ones the
newest main run did not verify, and links to the spec and the feature list
on GitHub.
Putnami reads the features from the default branch: every
putnami.features.json, specs/*.json and putnami.architecture.json. It
indexes a repository only once a Putnami platform admin turns its index on;
until then, Features says so. After each push to the default branch, Putnami
reads only the declarations the push changed. A requirement's state comes
from the verdict of the newest hosted CI run on main: a project that run
did not test shows its requirements as not verified at this commit.
Upload local gate sessions
A gate you run on your machine or in an agent session counts as a green gate
in escapes once Putnami has its session record. The upload needs a release
of the Cloud extension with local session upload. No such release is
available yet, so the reporter stays off by default and no session is sent.
Once that release is out, you turn the upload on this way:
- Install that Cloud extension release.
- Sign in with
putnami cloud login. - Set
PUTNAMI_SESSION_REPORTER=@putnami/cloudin the environment of yourputnamiruns.
Each run then sends its session record to
POST /v1/workspaces/{workspace}/ci/local-sessions/{session} under your
login. Your user needs delivery.run.manage on the workspace. A machine
token, such as PUTNAMI_CLOUD_TOKEN, is refused. The first upload of a
session binds it to your user: another user cannot add to it. Putnami stores
only the session record, session.json, and deletes the file after 30 days.
It accepts the other files of the session directory and drops them. From the
record it keeps the outcome, the commands, the branch, the commit and the
times, which the metrics read.
An uploaded session creates no CI run, and ci list does not show it. It
counts as a green gate for a merged pull request when all of these hold:
- The session succeeded.
- It ran
lint,test,buildorvalidate. - It ended before the merge.
- Putnami received it at most 15 minutes after the merge.
- It ran on the pull request's head commit with no uncommitted change, or on the pull request's branch after the pull request opened.
A session on the pull request's branch counts even when the branch moved after it. The commit match is the strict one. Putnami refuses a session record that ends after it arrived, give or take 5 minutes of clock skew, or that ends before it starts.
To list the sessions uploaded for a branch, call
GET /v1/workspaces/{workspace}/ci/local-sessions?repo=<owner/name>&branch=<branch>.
A workspace can bind several repositories, so the read names one. Add
head=<commit> to keep the sessions on one commit, and limit to read up to
100 of them (20 by default). The answer lists the newest first, each with its
outcome, commands, start and end, the user ID of its uploader and its commit,
and says more when more sessions match. Anyone who can read the
workspace's CI runs (delivery.run.read) can read them.
CI metrics
The console draws the same figures over time. Open CI metrics from the
CI runs list, or go to /w/<workspace>/ci-metrics. The page reads the last
30 days by default; switch to 7 or 90 days at the top.
Each metric has a daily chart and its total for the window:
| Chart | What it shows |
|---|---|
| E1 Revert rate | revertRate per day. |
| E2 Fix share | fixShare per day. |
| E3 Strict pairs | strictPairRate per day. The table also gives linksUnavailable as Links unavailable. |
| E4 Time to fix | medianDaysToFix per day. The total is the median over every strict pair in the window. |
| E5 Merged without a green gate | withoutGreenGateRate per day. |
| G6 Escape rate | escapes per day, as two lines: after a green gate (solid) and without one (dashed). The total and the table also give each group's median size, or size unknown. |
A day with no value is a gap in the line, not a 0. Under each chart,
Show the days as a table lists every day with its counts and says why a
value is missing: no merges, no pair, or, for G6, not computed: the
escape facts of the day are not complete. A later morning computes G6 once
they are, up to the seventh morning after the day. A chart with no value above 0 shows no peak. Before
the daily job stores a first day, the page shows No efficacy data yet.
When Putnami cannot read the figures, the page shows an error instead.
Recover deliberately
Mutating recovery commands require an audit reason. In a non-interactive
environment, also pass --yes to bypass the confirmation prompt.
putnami cloud ci retry <run> --phase lint --reason "transient failure"
putnami cloud ci retry <run> --phase deploy --reason "registry 503 during the rollout"
putnami cloud ci cancel <run> --reason "superseded commit"
putnami cloud ci repair --reason "reconcile stale run state"ci pause, ci drain, and ci resume change the workspace pipeline mode and
also require --reason. Use them as circuit-breaker operations, not as normal
run controls.
While the pipeline is paused, a push or pull-request update opens no run. Its
commit gets a neutral pipeline paused check, and Putnami keeps the request.
ci resume opens a run for each kept commit that is still current:
- the head of each open pull request, not an older commit of it;
- every commit pushed to the default branch, and every tag, in order;
- the commit at the head of another branch, if that branch still exists.
The pipeline paused check on each kept commit then changes to CI resumed,
and says whether a run opened. If Putnami cannot answer a kept request after
the resume, for example because the repository is not reachable, it retries.
If it still cannot answer a lane queue wait (4 hours by default) after the
first failure since the resume, it drops the request without a run and the
check says so.
A run that was queued when you paused stays queued. It starts after
ci resume only if you resume within the lane queue wait, counted from when
the run was queued. After that it ends as canceled without being built: start
it again with ci retry or a new push. A re-run pressed while paused is not
kept: press re-run again after the resume.
Retry a failed deployment
ci retry <run> --phase deploy reopens the rollout of a run whose deploy
phase concluded failure, or timed_out because the control plane gave no
verdict. It opens no new run: the control plane deploys the same release set
to the same environment again, under a new release id, and the run's deploy
phase gets a new attempt that carries that rollout's verdict. ci view <run>
lists every attempt; --reason is recorded with the attempt.
The new attempt's verdict becomes the run's. A run that had already concluded
failure on its deployment concludes again from it:
| The reopened rollout | The run | deploy and Putnami CI on the commit |
|---|---|---|
| deployed | turns completed / success |
turn green |
| failed | stays completed / failure |
stay red, with the new attempt's reason |
| lost the channel to a newer commit | turns completed / canceled |
show canceled |
| gave no verdict within 2 hours of the retry | stays completed / failure |
stay red; the attempt ends timed_out, and you can retry it again |
The run does not reopen: its status stays completed and only its conclusion
changes. While the rollout runs, the run and the checks keep the failure.
Putnami reads the verdict every 5 minutes while delivery-api is serving, and
once when delivery-api starts, so the run and the checks follow it within that
time. A retry stays in reach for 30 days after the last change to its run. If
GitHub refuses the deploy check, the next read publishes it again; until then
deploy shows what GitHub last accepted. Putnami stops trying 24 hours after
the new attempt finished; ci repair publishes the check after that. A run that failed for another reason
than its deployment keeps its failure; only its deploy check follows the new
attempt. A run that is still in progress when you retry ends with the new
attempt's verdict too.
The retry is refused when there is nothing to reopen:
| Answer | Why |
|---|---|
| 400 | the run declared no control-plane deploy, or its deploy never started |
| 409 | the deploy is still rolling, concluded something other than failure or timed_out, opened no release, already succeeded, or the channel moved on since (the next move covers the environment) |
| 503 | this Delivery is not wired to the control plane's release retry |
A second retry while the reopened rollout runs is refused with the attempt that is still rolling; it opens nothing.
Select producer tracks
A workspace can follow a producer channel or pin one exact immutable release set. The update is atomic and preserves the workspace's other tracks:
putnami cloud channels follow putnami stable
putnami cloud channels follow putnami canary
putnami cloud channels follow putnami <release-set-id>Add --runner-channel stable|canary to change the runner channel in the same
update. The CI subscription must already exist.
Complete command matrix
These are all 17 cloud ci verbs. Authentication and routing flags shared by
every verb are --workspace, --auth-url, --client-id, and
--control-plane-url; they are omitted from the rows below.
| Command | Purpose | Command-specific flags and arguments |
|---|---|---|
ci enable |
Create or enable the workspace CI subscription | optional --runner-channel stable|canary |
ci disable |
Revoke new-run admission | no command-specific flags |
ci subscription |
Read the current subscription revision and settings | optional --output=json |
ci list |
List runs newest first; the control plane applies the filters it supports | --limit, --repo, --sha/--ref, --branch, --pr, --status, --phase, --age |
ci view <run> |
Read one run, its attempts, and failure diagnostics | an unambiguous run-id prefix |
ci start |
Start a run for a pushed commit, or answer the default branch's run of it (see Declare the pipeline) | required --repo, --sha, --reason; optional --ref, --branch, --pr, --phases, --provider, --size, --max-parallel, --no-cache, --yes |
ci cancel <run> |
Cancel one run idempotently | required --reason; optional --yes |
ci retry <run> |
Retry the whole run or one phase; --phase deploy reopens a failed rollout on the same run |
required --reason; optional --phase, --size, --max-parallel, --no-cache, --yes |
ci logs <run> |
Read or follow the detailed log stream | --raw, --follow, --phase, --project, --q, --level, --from, --to, --cursor, --limit |
ci status |
Read aggregated CI readiness dimensions | no command-specific flags |
ci usage |
Aggregate substrate, profile, gate wall, estimated spend, and the billed cost per UTC day | optional --window (default 168h) |
ci insights <run> |
Read the contracted gate and cache-economics report | optional --output=json |
ci timings <run> |
Read the per-task timeline, longest wall first. With --against <other-run>, read why each task executed instead of being served by the cache |
optional --against, --limit, --output=json |
ci results <run> |
Read what the gate found: failed tests with their output, coverage per project against its threshold, diagnostics by file and line, and what it published | optional --output=json (every case the server kept) |
ci repair |
Terminalize stale rows and reconcile terminal checks | required --reason; optional --yes |
ci pause |
Stop new admission with an audited circuit-breaker change | required --reason; optional --cancel-running, --review-ref, --incident-ref, --yes |
ci drain |
Stop new admission while allowing running work to drain by default | required --reason; optional --cancel-running, --review-ref, --incident-ref, --yes |
ci resume |
Return the workspace pipeline to active mode, start queued runs, and run the commits kept while paused | required --reason; optional --cancel-running, --review-ref, --incident-ref, --yes |
ci help --output=json returns the installed command inventory for automation.
The manifest currently declares 33 CI flags; every one is either named in this
matrix or in the shared-flags sentence above.
Next
Decide a change in the app
A change page in putnami.app has eight tabs, in the order a change goes
through: Intent, Spec, Archi, Code, Checks, Proof, Verdict and Release. Each
tab says under its name where that step stands. Checks shows the final gates
on the change's last commit, the reviews that wait for a person, and the
history of runs. Release shows the pull request's pr-N channel, what the
merge released, and what each environment serves. The Proof tab leads with
the proof diff against main: the counts, then each requirement the change
lost, adds without a proof or newly proves, each linking to its row below and
to its feature page. A new requirement links no feature page: main does not
hold it yet. A lost requirement that blocks nothing says "lost, for
information". The full list follows, and opens only the features that hold a
lost or new requirement, a lost one for information aside.
A workspace admin reads and approves the waiting declarations on the Spec or the Archi tab. Each block reads like a file in a code review: a header with its lines added and removed, the formatted text, then Approve intent, which approves that block's files at the displayed commit, without leaving the page. To approve several blocks at once, tick their headers and choose Approve selected, or choose Approve all. A file that several features share has its own block and is approved once, there. Reload after a stale-commit refusal. The Code tab lists every changed file, the declarations included. Each requirement shows whether the change's run proved it, and each block, requirement and check links to its place on the other tabs. When an agent session works on the change, its owner can use Comment for the agent under a file: the session receives the message at its next sync. Approvals follow later pushes on the same pull request when the file's bytes stay identical, including a file absent at both commits. A changed, added, deleted or unreadable declaration needs approval again. A carried approval keeps the original person and time.
The comparison uses the two head commits. Moving the base branch does not reset approval when the declaration's head bytes stay identical.
The checks of a pull request wait for its declarations. When its head changes a spec or an architecture file that nobody approved at that head, no run starts. The check declarations to approve on the commit names each file and links to the change page, and Work lists the change under Waits for you with "Checks wait for approval". Your last approval starts the checks, wherever you give it: on the change page, on a run's verdict, or with Approve intent on the check. Drafts get the same check. On a draft, your last approval passes the check, and the checks start when you mark it ready for review. To run them before you approve, choose Run the checks on the change page, add the workspace's run label to the pull request, or run:
putnami cloud ci start --repo <owner/name> --pr <number> --sha <head> --reason "<why>"The verdict of that run still waits for the approvals.
The page also lets a workspace manager merge, close, convert to draft, or mark an open pull request ready for review. These actions require signing in through GitHub and current write, maintain or admin access to the repository. The Putnami GitHub App performs the action and comments with that GitHub login publicly before acting. Merge is a squash at the displayed head and is offered only when the repository allows squash merging. GitHub enforces its required checks and reviews. Closed and merged pull requests offer no lifecycle actions.
Marking a same-repository pull request to the default branch ready can enable Source's squash auto-merge when the branch rules require the verdict check. GitHub can then merge it after checks and reviews pass, without another click. Draft prevents merging; Source does not enable auto-merge for drafts.