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=json

New 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 status

list 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 main at 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 main at 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 72h
Billed 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 24h lists 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.
  • escapes needs 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, with escapes set to null until the escape facts are complete too. Putnami waits for them until the seventh morning after the day. If they are still missing then, escapes stays null.
  • A pull request whose size Putnami does not know, with no added, deleted or changed file recorded, counts in escapes but not in medianSize. medianSize is null when no pull request of the part has a known size.
  • withoutGreenGateRate counts only hosted CI runs. escapes also 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, efficacy is absent. When Putnami cannot read the computed days, efficacy is absent too and efficacyUnavailable is true.

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:

  1. Install that Cloud extension release.
  2. Sign in with putnami cloud login.
  3. Set PUTNAMI_SESSION_REPORTER=@putnami/cloud in the environment of your putnami runs.

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, build or validate.
  • 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.