* feat(search): update GitLab permission CSVs through the API
* fix(search): align GitLab CSV updates with CLI and API policies
* test(cli): cover confirmation for GitLab permission replacement
* Revert "improvement(org): move the People page onto the new design system (#9720)"
This reverts commit 76259293f2.
* Revert "fix(org): drop the removed shortcuts slot from the landing test (#9715)"
This reverts commit f17f1b6795.
* Revert "improvement(org): move the organization view onto the new design system (#9708)"
The redesigned org view ships all at once with #9687. The shared modules later
staging work builds on stay: member-integrations and the accounts key factory.
The legacy integration detail opens the saved-credential modal for Jama and Flow,
which #9723 added only to the new view.
* fix(org): keep staging's shared modules and revert only the redesigned views
Hooks, contracts, key factories and lib helpers stay at staging, and the legacy
view adapts to them. Jama and Flow reconnect through the saved-credential modal
and disconnect through Search. Exports only the new views used are unexported or
deleted, and the e2e script returns to the legacy view's selectors.
Move the organization view onto the Platform design system: sidebar, Home with Email, Calendar and activity widgets, Integrations, Sim Links, and Search as its own destination, with server prefetch for the first read.
Members now land on Home with the Assistant composer. Styles stay scoped under data-platform-ui and check:platform-css enforces the boundary.
Run push validation independently of the deployment queue, and require the exact trusted successful run before migrations. Preserve deployment and release ordering.
Validate the admission protocol with real Bash/jq boundary cases and guard mutations.
* improvement(ci): fetch only the docs acceptance revision
* improvement(ci): install only the Chromium runtime each suite uses
* improvement(ci): keep library media on the landing acceptance path
Select acceptance work from the task graph, separate docs site and platform checks, and preserve complete comparison history for push attribution.
Build docs once and run isolated acceptance groups in parallel after bounded server readiness. Reuse validated content and incremental build inputs with bounded retention.
Validate native source/toolchain fingerprints and restored output integrity, seed trusted branch caches, and balance desktop smoke across four whole-file shards. Bound organization-search diagnostics and reclaim closed-PR merge-ref caches.
Validation: full root tests, all workspace types, lint and 62 audits; real cache invalidation and Git attribution controls; complete hosted docs, integration, organization-search, Electron and packaged smoke coverage; final-head bot reviews.
Run extension native and access acceptance in parallel with independent fixtures, apps, databases, and reports. Overlap independent desktop-pickup deadlines and isolated recovery backoff cases, and use faster integration runners with the existing GitHub fallback.
Update Playwright for the upstream WebKit compositor fix and disable focus emulation at the native blur boundary after reloads. Preserve all acceptance assertions and real timing contracts.
Validated with root tests, all workspace type checks, lint, all audits, generated-artifact checks, real integration and Electron acceptance runs, and negative controls for the protected behaviors.
* feat(people): organization People page with profiles, reporting lines, and people-data import
* fix(people): clearable manager and department pickers, exact spreadsheet dates and row numbers, loop checks through suspended members
* fix(people): consistent profile reads, capability-aware navigation, unambiguous email matching, stricter dates, guarded workbook parsing
* fix(people): read a page and its managers from one snapshot
* fix(people): send import rows as positional cells so wide files stay within request limits
Org-scoped Sim links: sim/<name> redirects with case- and punctuation-insensitive names, {*} variable links with same-site defaults, unlisted and restricted links, visit counts with a most-used view, an illustrated empty state, audit entries, and the org-scoped sim-links feature flag. Destinations keep a fixed http(s) origin; dot-segment values and control characters are refused.
Remove the redundant Assistant tool rollout gate while retaining organization access, account ownership, source restrictions, and action approval policies.
Keep Search editing and submission disabled until hydration is ready, then autofocus the field. Cover early edits and draft restoration with a held-script browser regression.
* fix(ci): predict the promoted app digest instead of trusting a read right after the retag
* fix(ci): bound the promoted-tag wait by elapsed time and each ECR read by a timeout
The app pipeline's Deploy stage can now also run a CodeBuild image deploy
for the sandbox worker host. The cutover wait required exactly one Deploy
action, so Trigger.dev promotion failed whenever that action was present.
Select the CodeDeployToECS action by provider; everything after it is
unchanged.
## Summary
- Add a daily `ci-flakes` workflow (`scripts/report-ci-flakes.ts`): a job that failed on a CI attempt and passed on a re-run of the same commit files one `ci-flake` issue per failing test (Vitest `FAIL` lines and the E2E harnesses' `[Suite] FAIL` lines), or per job when its log names none. Occurrences are keyed by job id, so the overlapping 3-day lookback never double-counts, and a closed issue reopens when its flake recurs. Dependency-free, so the job needs no install
- Fix the live flakes found in the last two weeks of re-runs:
- GitHub rate-limit reset test: pin the clock; a second boundary between building the header and reading it gave 899000
- OAuth token and token-family integration tests: import the auth graph statically, so its cold load (up to ~43s on a slow runner) no longer counts against the first test's 30s timeout
- stop-after E2E: wait for the sibling-pause claim until the resume request settles, not a fixed 2s that a slow `next dev` round trip outlasts
- HTTP E2E readiness: 300s → 600s; healthy cold compiles take 60–185s and a degraded runner ran past 300s with every step 3–6x slower
- Reconciliation-window integration test: print each scan's plan when a window statement reads past the bound, so its next failure names the cause (diagnostics only; the cause isn't confirmed yet)
- Mobile e2e and usage-log flakes were already fixed by later commits, so nothing changes there
- Testing rules: a short section on the flake workflow and how to fix one (no retries, longer timeouts, or skips)
* improvement(seo): fix soft 404s, per-integration freshness, and docs markdown for AI crawlers
* test(seo): crawl the production build for landing SEO regressions
* chore(landing): remove the post and author loading skeletons the slug pages no longer use
* fix(seo): resolve docs slugs through the catalog, keep API pages negotiable, and harden the crawler suite
* fix(docs): carry the landing-page backlink into integration markdown
* test(seo): match the visible date attribute case-insensitively
* ci: ratchet type errors in apps/sim unit tests per file
apps/sim's tsconfig excludes *.test.ts(x), so ~3.4k test files are never
type-checked and any new test can add errors. check:test-types runs the
native tsc on apps/sim/tsconfig.tests.json (the app config with tests left
in), counts errors per file, and compares with a shrink-only baseline,
matching check:explicit-any's semantics: a rise or a new file fails, a drop
fails until --update shrinks it, --update never raises, --update --init only
creates a missing baseline. Output it cannot place (global diagnostics, a
crash) fails outright instead of reading as fewer errors.
It type-checks the whole app, so it runs in its own test-types job gated
like test (wired into ci-gate.sh), not in check:audits. On failure the job
uploads counts.json and the compiler output; --counts <file> lets the
baseline be bootstrapped or shrunk from that artifact without a local
compile.
* ci: commit the test type-error baseline from CI and drop the one-time --init path
Baseline from run 38342772080's test-types counts: 3209 errors in 874 files.
--update stays shrink-only; a missing baseline is restored from git.
* ci: ratchet test type errors per file and TS code, with command-level tests
A per-file count let one new error replace a fixed one with the total flat.
The baseline is now { file: { TSnnnn: count } }: any (file, code) count
that rises fails, including a new code in a baselined file, and --update
stays shrink-only per pair. The key stops at the code: line and column
move with edits, and messages print types that change with unrelated
source or compiler versions.
--diagnostics <file> replaces --counts: it reads a saved compiler output
(the CI artifact's diagnostics.txt) through the same parser and undercount
checks, so a fix can shrink the baseline without a local compile. The
baseline was migrated from run 38342772080's diagnostics.txt with the
script's parser: 3209 errors in 874 files across 52 codes, every per-file
total equal to the previous baseline's.
Command-level tests run the real script on fixture diagnostics: unchanged,
a rising count, a new code replacing a fixed error, a new file, a dropped
count, --update refusing a raise, --update shrinking, and unparseable or
inconsistent output. The checks.yml comment now describes the artifact as
input for shrinking the existing baseline.
* ci: verify saved test-type diagnostics against the compile's exit status
--diagnostics read an empty or truncated diagnostics.txt as fewer errors,
so a failed compile's artifact plus --update could erase the baseline.
--report now writes status.json (exit code and printed error count) once
the compile's output and exit code agree, and --diagnostics requires it:
exit 0 must mean no errors, the parse must match the recorded count, and
a missing or malformed status fails. Command-level tests cover each case
and that --update never writes the baseline from such input.
Also passes a route context to the socket-token route test's POST call,
the one new test type error (TS2554) the ratchet caught after #8958.
* ci: read the saved compiler status through toRecord
* ci: run the mobile e2e suite on the shared production build, one job per browser
The build job now packages .next (zstd, cache excluded) and uploads it for a
day. A new e2e-mobile job, one per browser (chromium, webkit), extracts it and
serves it with `next start`, so the suite no longer waits on dev compiles or
runs both browsers back to back. The mobile group leaves the e2e matrix.
On runs that execute e2e, the build bakes NEXT_PUBLIC_APP_URL=http://localhost:3000,
which is what production images bake, so the served build is the one that ships.
Content-only pull requests keep the hosted value, under which next build
prerenders every post.
http-e2e.sh gains a `next start` mode used only by mobile: it installs only the
selected browser, drops the dev heap override, and rebuilds the HTTP status log
from RouteHandler's JSON lines at LOG_LEVEL=INFO. The ci gate treats e2e-mobile
like e2e: a skip passes only when `full` is exactly false.
* ci: build mobile's artifact in its own job and keep the hosted build untouched
The `build` job is back to staging byte for byte: its www.sim.ai build is CI's
only render of every post, and it must stay on every run. A new `e2e-build`
job, gated on `full` with its own Turbo cache key, builds with
NEXT_PUBLIC_APP_URL=http://localhost:3000 (the Dockerfile default, so the same
public-env mode production images use; images run the standalone server) and
packages and uploads it for e2e-mobile, now kept 3 days and without
.next/trace.
e2e-mobile fails fast when the downloaded build prerendered posts, which only a
hosted build does; the URL is no marker, since next.config's redirects name
www.sim.ai in every build. The ci gate treats e2e-build like e2e.
* ci: key the non-hosted guard on prerendered post pages, not every /blog/ route
* ci: expect the socket-token rate limit in the mobile e2e suite
Each document load mints one realtime token from a route capped at 30/min
per IP. On the production build the suite loads well over 30 documents a
minute from loopback, so the route's designed 429 is recorded apart from
httpErrors (only with Retry-After), and each browser must still mint at
least once.
* ci: scope pull request checks to what the diff can affect
A `changes` job classifies the pull request's files against explicit
allowlists (.github/scripts/ci-changes.sh, replacing
desktop-live-changes.sh):
- content posts, author profiles and their public assets: lint, test, build
- apps/docs: lint, test
- apps/desktop: lint, test, desktop-live
- agent guidance (.agents, .claude, .cursor, AGENTS.md, CLAUDE.md, root README): lint
Any other file, any .github change, an empty diff, or a diff that cannot
be worked out runs everything; pushes and dispatches always run
everything. The live desktop suite keeps its own skip list, now including
the content asset folders it previously missed.
`ci` accepts a skip only when `changes` set that job's flag to exactly
`false`, so a failed or skipped `changes`, or a lost output, fails it.
* ci: move the ci gate into a tested script and reject non-boolean change flags
The ci aggregator's skip rules now live in .github/scripts/ci-gate.sh, read from
NEEDS, with table-driven tests covering every guard. The change-classifier test
helper fails on any flag value other than exactly true or false.
* fix(e2e): connect the mobile suite to realtime and give dev-server round trips the server budget
- Start the realtime server for the mobile group. Without it every workspace page raised a
persistent "Reconnecting..." toast ~2s after load; on the locked-workflow reload it raced the
lock toast and, when it arrived second, sat in front of the Unlock Workflow action, so the tap
timed out on "subtree intercepts pointer events"
- Wait 120s, the suite's budget for a next dev round trip, for the URL after a sidebar link tap,
the Files list after it, and the table cell after a reload. next dev spent 16.4s (application
code 70ms) serving the /home RSC payload and left the rows request unanswered past 20s
- Install the browsers while the app boots
* fix(e2e): stop the background browser install on exit and surface install and realtime logs on failure
Make navigation, chat composers, resource controls, settings, and workflow panels fit narrow touch screens while preserving desktop and fullscreen layouts. Add the Chromium/WebKit mobile CI matrix and the mobile design-review checklist.
Keep workflow actions visible in compact panels and attachment scrolling bounded, with shared cues for hidden content. Stabilize clock-sensitive billing assertions and the post-commit connector deletion test without changing production behavior.
* improvement(desktop): ship the background executor without a flag
* fix(desktop): wait on the shell's own startup signal before refusing a run
A background terminal run on a fresh shell waited a flat 8 s for the first
prompt and then failed with NO_SHELL_INTEGRATION. A startup file that stops
at a question (oh-my-zsh's update prompt) holds the prompt indefinitely, so
the run failed with a message blaming the shell's integration.
The generated startup files now send a SimStartup marker before any of the
user's files run. A shell that never sends it within 8 s of spawning is not
instrumented and is refused as before (an unsupported shell at once). One
that did gets 30 s to reach its prompt, which tolerates slow startup files
on a busy machine; past that the run is refused with the screen it is stuck
on, so the agent can ask the user to answer it. Stop now ends the wait, and
a shell that exits mid-wait reports SESSION_CLOSED.
* test(desktop): durable E2E reports, hermetic shells, and a real network cut
- background-executor and terminal-cancel record each check through one
shared helper as it finishes. The background-executor report was written
from module state in afterAll, so a worker restart after a failure wiped
it and the report could read green. Reports from an earlier run are
replaced, not appended to. check-report.spec.ts forces a worker restart in
a nested Playwright run and asserts the failure stays.
- The executor fixture launches the app with zsh and an empty ZDOTDIR, so a
developer's .zshrc (an unanswered oh-my-zsh update prompt) cannot hold the
first prompt and fail unrelated scenarios.
- Scenario B now cuts the network at the socket level: every open
connection, the doorbell stream included, drops and new ones are reset.
It asserts the result lands exactly once, the doorbell reopens, and new
work is picked up after reconnecting.
* test(desktop): a call declined in a background chat is never claimed or run
The fixture Sim can now decline a held call the way Sim settles it, and the
executor suite checks the device never claims it and its command never runs
after the approval notification.
* test(desktop): run the live desktop suite with the background executor on
The live suite's Sim has Redis, so with the executor shipped always-on every
turn now binds to the app and runs in the background. The proxy answers the
app's registration as an install without Redis would, so the chat-view tests
keep covering that path, and the round trip asserts the app stays dormant.
Two tests let Sim's own answer through: a call issued after the user switched
chats runs on the desktop, and a result reported across a network cut (every
connection dropped, the first report landing late) reaches the agent exactly
once.
* fix(desktop): measure a shell's startup bound from when its startup files began
The 30 s bound ran from spawn, so a shell whose startup marker arrived late
on a busy machine got less than the promised time for its startup files.
The deadline now starts at the marker.
* test(desktop): drop the outer runner's variables with the shared omit helper
* ci: shard integration and unit tests, run e2e groups in parallel, add a ci gate
The PR critical path was the PostgreSQL integration suite (~15 min), run in full on an
8 vCPU runner once per provisioning path. Its files run one at a time, so the runner sat
mostly idle.
- integration: each provisioning path (push, migrate) is split into 4 Vitest shards on
4 vCPU runners. Both paths keep the full suite: migrations add triggers, checks and
NOT VALID constraints that db:push does not, so the schemas differ.
- e2e: the four next-dev groups (scim, cli, stop-after, desktop-inbox) run as a matrix,
each on its own database. The boot/wait/stop shell lives once in http-e2e.sh.
- lint: lint, audits, type-check and schema sync split off from the tests.
- test: apps/sim unit tests sharded 2 ways; shard 1 also runs root scripts and the other
workspaces. Each shard has its own Turbo cache disk.
- ci: one aggregate job that fails unless every check passed (skipped is allowed), so a
ruleset can require a single stable check.
Deploy gating is unchanged: migrate still requires the whole Test and Build workflow.
* ci: short names, one setup action, aligned pins, explicit secrets
Naming
- Workflow files: test-build -> checks, migrations -> migrate, deploy-trigger-dev ->
trigger-dev, docs-embeddings -> docs, companion-pr-check -> companion, stickydisk-gc
-> disk-gc. ci.yml, helm.yml and codeql.yml keep their paths: they sign or analyze, and
the path is part of the signer identity and code-scanning key.
- Composite actions: setup-workspace -> setup, cache-mount -> cache, docker-build -> image.
- Every workflow and job display name is a short lowercase id, matching the job id, with
any matrix value in parentheses: ci / checks / integration (push, 1/4), image-amd64 (app).
Duplicates
- Nine hand-written Setup Bun + actions/cache + bun install blocks use the setup action.
It gains node-version (empty keeps the runner's Node, as those jobs had) and registry-url
(npm publishing). This also ends restoring node_modules from another lockfile through the
`${runner.os}-bun-` prefix restore key.
- The runner expression is anchored once per file and aliased after.
Consistency
- One SHA per action: checkout v6 (helm was on v4, codeql on v5), setup-node v6 (desktop
on v4), cache v5 (desktop-release on v4), softprops/action-gh-release v3.0.3 (was v1,
Node 16). Redis 8.2 everywhere.
- secrets: inherit replaced by the secrets each callee reads; the checks workflow reads none.
The dev migration gets only DEV_DATABASE_URL, and staging/production never see it.
- Timeouts on the three macOS desktop-e2e jobs (none before, so a hang billed 6 hours),
and a cache for their Electron, electron-builder and Playwright downloads.
- Publish workflows: values moved from ${{ }} in run blocks to env, concurrency on the
npm/PyPI publishers, persist-credentials: false on checkouts that never push.
- Dependabot for github-actions (one grouped weekly PR), and actionlint in the lint job.
Fixes
- PyPI version check matched substrings (0.1.1 "existed" once 0.1.10 did) and treated a
PyPI outage as "not published". It now asks PyPI for the exact version and fails on
anything but 200 or 404.
Job wiring (runner, if, needs, permissions, timeout, outputs) is unchanged: verified by
loading the old and new ci.yml, checks.yml and helm.yml and comparing every job.
* ci: run the ci gate on cancelled runs so a cancelled head never passes
* docs(desktop): point the release notes at the renamed workflow and jobs
* improvement(desktop): Electron E2E for desktop tool lifetimes against a live local Sim
Runs the real Electron app against a local Sim (Postgres, Redis, realtime) with a
recording proxy and a scripted stand-in worker, covering chat switches, Stop,
sign-out, approval-gated and stopped claims, and the flag-off foreground round trip.
The spec skips unless a live Sim is configured; the http-e2e job provides one.
* improvement(desktop): use shared helpers, confirm Redis MONITOR, stage desktop build on the workspace disk
* improvement(desktop): bundle the desktop app without macOS prebuilds in the Linux E2E step
* improvement(desktop): report desktop E2E failures inline and trace runner memory
* improvement(desktop): run the live desktop E2E in its own job on a larger runner
* improvement(desktop): warm the live desktop E2E routes and wait on outcomes instead of time
- Compile every route, page and client chunk the tests use in a named warm-up step before any timed hold
- Send retries only while no turn reached Sim; every held request and poll is bounded
- Stop and sign-out tests wait for the import's own report and assert one exact terminal state
- Clicks fail fast with the dev overlay's error instead of a blocked click
* improvement(desktop): retype and resend a message the hydrating composer dropped
* improvement(desktop): run the live desktop E2E against the merged background executor
- The dormancy check accepts the app's own registrations, refused while signed out and answered
as not enabled once signed in, and still forbids inbox, doorbell, claim, lease and completion
- The app and realtime server run in their own sessions and stop through stop-session.sh
* improvement(desktop): release the held read at the moment its view lets go, and report the call's error on a wrong terminal state
* improvement(desktop): read the chat body's desktop capabilities with toRecord
* improvement(desktop): hold the read's own report across Stop, dismiss dev console notices, and keep failure diagnostics
* improvement(desktop): stop the live E2E apps by their E2E_APP tags
* improvement(desktop): deliver the claim held across Stop to Sim even if Electron gave up on it, and require its 410
* improvement(desktop): warm every route the live E2E reaches, keep sends honest, and check dormancy layer by layer
- Warm-up runs the tests' own flows (read, import, a chat switch during a live turn, Stop, login)
and waits until every request the app made has been answered
- send() resends only when the UI did not take the message; a taken message whose turn never
reaches Sim fails as a lost send
- Stop and sign-out tests assert exact outcomes without holding the tool's report (the stopped tool
reports nothing since #8732)
- Dormancy checks registration, device records, binding, routes and the doorbell as separate soft
assertions
- CI: per-run E2E_APP tags, retries 0, and a path filter for pull requests
* improvement(desktop): wait with the shared sleep helper while the dev app settles
* improvement(ci): detect live desktop suite changes with git, covering chat pages and auth routes
* improvement(ci): run the live desktop suite unless every change is clearly unrelated, and fail open
- The change check skips only docs, the other apps and published content; any change elsewhere,
and any failure to fetch or diff the base, runs the suite
- settled() discounts only requests a hold is keeping from Sim right now
- The warm-up's Stop turn waits for its stream to close instead of on a promise that never settles
- dedupe PIDs from the session and tag scans (`ps` pads them, so `sort -u` missed repeats)
- print the "outlived its leader" heading only with the rows of the same scan under it
- apply the two-empty-scans rule at the deadline too
- refuse an empty tag or a non-numeric leader instead of matching `E2E_APP=`
- keep the expected-flush label in its own column so rows stay aligned with the ps header
- silence /proc reads for processes that exit mid-scan
* fix(ci): match E2E app tags literally, make them unique per run, and never stop the caller
- stop-session.sh matches `E2E_APP=<tag>` as a fixed string, so a tag like `s.im` or a
prefix like `sc` no longer matches another app's `E2E_APP=scim`
- each HTTP end-to-end app's tag is `<app>-<run id>-<attempt>-<shell pid>`, so it is unique
among the runner user's processes
- the script never signals itself, its ancestors or its own subshells, even when the caller
exported the same tag; /proc is read without forking so scans stay cheap
- a surviving Next telemetry flush is labelled as expected, so an unexpected escapee stands out
* fix(ci): never spare an app process whose ancestry changes mid-scan, and confirm an empty app on two scans
* fix(e2e): re-signal session stragglers on a monotonic clock and report HTTP E2E failures once, by route
- stop-session.sh times its grace period from /proc/uptime, which is monotonic and
free of the locale's decimal separator, re-signals every 0.1s so a process that
joins the session after the first signal is stopped too, and explains why zombies
don't count
- version compare: a request whose body times out names its route like a request
that never answered
- desktop inbox: callers that join an executor pull in flight share it, so a failed
pull is logged once
* fix(e2e): log a failed executor pull with its stack
* fix(ci): also stop the detached telemetry flush an HTTP end-to-end app leaves behind
`next dev` spawns its telemetry flush detached, in a session of its own, even with
telemetry disabled. That process outlives the app's session and writes .next/dev/trace
after stop-session.sh returned, so the next app's `rm -rf .next/dev` could fail with
"Directory not empty". Each app now starts under an E2E_APP tag that every process it
spawns inherits, and stop-session.sh stops and waits for tagged processes as well as the
session's members.
* fix(e2e): compile every timed route first in the HTTP suites and stop sessions completely
- version compare: a first check compiles the deployment, version, compare and MCP
routes under a 300s budget; later requests stay at 60s and a timeout names the route
- desktop inbox: the warm-up also reads the inbox, so the 10s executor window covers
no compile; stopping the executor waits for its in-flight pull, so teardown never
runs under a claim and a timeout is reported as itself instead of a later 401
- stop-session.sh signals every process in the session, including one in its own
process group, escalates to SIGKILL 10s after SIGTERM, and reports processes that
outlived the leader only once the leader has exited
- stop-after: a CLI that overflows its output buffer is reported as an overflow, not
as a timeout
* fix(ci): run the embedded CLI app with the same isolated lifecycle as the other HTTP end-to-end apps
* fix(ci): start each HTTP end-to-end app from an empty Turbopack dev cache
The stop-after suite failed 12 of 175 CI runs (Oct 1-6), always in its own
`next dev` app, which restored the Turbopack dev cache (.next/dev) the
SCIM/version-compare app left in the same job. That app ran with other
NEXT_PUBLIC_* values, and `next dev` SIGKILLs its server 100ms after SIGTERM.
Restoring the cache:
- panicked Turbopack at startup (inner_of_upper_lost_follower), 6 runs;
- panicked mid-compile of the execute route ("socket connection was closed
unexpectedly"), 4 runs;
- wedged that compile until the 300s request timeout ("The operation timed
out."), 2 runs.
No run reached the executor: the cleanup check found no open execution log.
- Each app step removes .next/dev before starting, so no app restores another
app's cache.
- A failing step prints the server log tail, not only a startup failure.
- The suite compiles the execute route with a refused request under its own
300s budget and named check; every later request and CLI run is bounded at
60s. A timed-out or dropped request names the route and elapsed time, lands
in the report with a null status, and a CLI timeout is reported as one.
* fix(ci): start the desktop inbox app from an empty Turbopack dev cache too
* fix(e2e): record a status only for a fully read stop-after response
* fix(ci): stop each HTTP end-to-end app's whole process session before the next one starts
* fix(e2e): compile the desktop executor routes before timing executor calls