Start here

What a run leaves behind

What each integration does today, what is Beta, and exactly what each one still does not cover.

Reviewed 2026-10-02

After a run you want to know what happened, in what order and what it cost. This page lists each piece, what it does today and what is missing, so a missing item is never a mystery.

Three status words are used, and only these:

Works today: it has been used on real runs, and there is a command that shows it working.
Beta: it works in part. The row says exactly what is missing.
Coming next: it is not built yet. Nothing here should be read as working. A feature that ships leaves this state, so no row below is Coming next right now.

Status matrix

Piece	Status	Works today	Not yet
Server, tunnel and teardown	Works today	`chalupa up`, `chalupa tunnel` and `chalupa down`. Compute is destroyed and the protected data volume is left intact. Check it with `chalupa status`. `chalupa receipt` prints a timing and estimated-cost line for each session.	Receipt costs are estimates from the provider's price, not an invoice, and the ledger lives on the machine that ran the session.
Data volume	Works today	A declared volume lives in its own stack and survives teardown. Check it with `chalupa status`.	Nothing deletes it for you: it bills monthly until you remove it on purpose.
Expiry backstop	Beta	Declare a session expiry and, on Hetzner or GPU setups, arm the hosted reaper with a scoped provider token in `chalupa setup`, or register a local teardown runner, so an expired server is destroyed.	`chalupa setup` offers the hosted reaper only for Hetzner and for GPU setups; DigitalOcean Compose servers rely on the local runner today, and the hosted path needs a linked console account. The local runner needs an awake, unlocked machine. It is not a plan feature.
Browser flows	Works today	Run your flows from your laptop against the tunnelled ports and keep the video, screenshots and report. They can also run as a `uses: cairntrace` step of a `ci:` suite on the server, beside the app.	The on-server step needs the toolchain baked into your server image (`chalupa snapshot build --toolchain onbox`).
Evidence storage	Beta	`ci:` runs attach evidence to the run. A failed laptop run is stashed locally and `fcheap restore <id>` brings it back. Evidence stored in file.cheap cloud opens from the console run page.	Passing laptop runs are not attached to anything. Laptop evidence cannot be uploaded for the console to open (`report.evidence.publish: cloud` is refused today), so the run page shows its restore command instead.
Crash capture	Beta	`ci:` runs with `ci.monitor` capture the stack trace and culprit frame of a failing step. With `observability.crashCapture`, any container death in the Compose projects you list is recorded on the box and shows in `/app/issues` beside the CI ones. Host metrics work on one provider.	Capture listens to Docker container deaths, so it needs Compose and covers only the projects you list. The second provider's host telemetry and containers outside your Compose projects are not covered.
Secrets	Beta	`overrides.<service>.env: { NAME: "${NAME}" }` plus `tvault run --only NAME -- chalupa up`.	Values are written to the server's startup config and to local state. `env_file` is not supported. Runtime delivery is coming next.
Logs	Beta	Logs of the Compose services you opt in with `session.logs` are collected as log chunks. The console shows the first lines of each chunk for 24 hours, a run page shows the excerpts inside that run's window, and chunks can be downloaded within your plan's retention. `chalupa logs` reads a running server's logs directly.	Collection can stop at its chunk limit or the original deadline. A service with its own non-journald logging driver must be excluded, and containers outside your Compose file are not collected. Searching collected logs in the console is not built yet.
AI agents (MCP)	Beta	`chalupa mcp` discovers your environments, then reads status, sessions with a stage-by-stage timeline, bounded box logs, the box side of a failed cairn run, recent test runs, cost, the action contract, live CI status and experiment results. Also `chalupa explain --json` and `chalupa connect --format app-brief`.	Launch and teardown are not MCP tools. Evidence files (screenshots, videos, reports) cannot be opened over MCP. See Chalupa for agents.
Hosted console	Beta	Run history, a page per run, CI runs, issues, performance windows and comparisons for the environments you link.	Log excerpts are short, and only evidence stored in file.cheap cloud opens there. The console shows what your environments report; it does not control servers.
Run page	Beta	`/app/runs/<id>` shows the failing step, the evidence attached to it, the logs and containers in that run's time window, and the cost of the window.	Evidence opens from the page only when it is stored in file.cheap cloud; a laptop run shows a restore command instead of the files. Logs are short excerpts and need `session.logs`.

Where evidence goes

Run from your laptop. Browser flows (CairnTrace) and anything else you run against the tunnel keep their output on your machine. A failed run is stashed in your local file.cheap vault, and fcheap restore <id> prints it back. A passing run is not stashed automatically. Nothing from a laptop run is uploaded unless you set that up yourself.

Run as a ci: suite. Steps run on the server. The engine packs each step's evidence and publishes it to the artifact service when the environment carries an ingest credential. chalupa down also collects the settled run's reports and packs into ~/.local/state/chalupa/ci-runs/<runId>/ before it destroys the server, one directory per run, so a later run never overwrites an earlier one. It is best effort. An expiry-driven teardown from the hosted reaper destroys the server from the cloud side, where no local collection can run.

Check a suite with:

chalupa ci status
chalupa ci artifacts
chalupa ci report

Logs: excerpt versus download

The console shows short redacted excerpts, the first lines of each collected chunk, for 24 hours. Complete log chunks are downloadable for as long as your plan retains them: 7 days on Solo and 30 days on Crew. Community keeps history locally. Collection is bounded by the session's byte budget and a 256-chunk ceiling, so a noisy service can fill its budget before the run ends. See private log artifacts.

Run browser flows on the server

CairnTrace can also run as a ci: step on the server, beside the app. Browser steps always run on the server host, and the failed-step evidence rides the same artifact pack:

ci:
  suite: browser-smoke
  steps:
    - id: browser-specs
      uses: cairntrace
      environment: chalupa
      specs: [flows/checkout.yml]
  onFailure:
    investigate:
      enabled: true
      pids: [api, top_cpu]

onFailure.investigate captures an incident with Monitor when a step fails. Its alternative, onFailure.record, records a video of the failing step with vidtrace; a run arms one of the two. Both are best effort: a missing tool is reported, never a changed result. Chalupa does not install them for you, so bake them into your server image. Collecting trace or video output makes failed runs large, so turn them on while debugging a specific red run rather than by default. See Declarative CI.

Missing something?

Troubleshooting walks through the usual reasons a piece of evidence is not where you expect it.