wake / root/cursed-monorepo Self-contained X-Ray artifact (zero external requests)
Source: gitlab / Pipeline #1 (develop) / Status: failed / Generated 2026-11-22 11:35
Wall-clock time
2m 59s
Estimated optimized
32.3s (5.6x)
Total runner compute
4m 32s
Findings detected
7
Critical path build-nix-env → test-api-unit → test-api-integration → lint-and-format

Pipeline waterfall

Queue wait Container prep, git, cache overhead Script execution Critical path
Job
0s45.5s1m 31s2m 17s3m 02s
build-nix-env critical
build · 1m 43s
1m 43s
build-api
build · 24.0s
24.0s
build-worker
build · 23.9s
23.9s
build-web-ui
build · 19.0s
19.0s
test-api-unit critical
unit-test · 21.8s
21.8s
test-web-ui
unit-test · 7.5s
7.5s
test-api-integration critical
integration-test · 32.9s
32.9s
test-worker-integration
integration-test · 30.0s
30.0s
lint-and-format critical
lint · 10.4s
10.4s
Hover or click any job row to inspect phase timings (queue, prep, git, cache, script).

Slowest individual tests

Top 6 cases by execution time
Duration Share Suite Test case Status
6.5s
test-api-integration tests.test_integration::test_integration_polling_retry success
5.0s
test-worker-integration tests.test_worker::test_worker_large_window_simulation success
3.0s
test-worker-integration tests.test_worker::test_worker_empty_window success
2.5s
test-api-integration tests.test_integration::test_integration_batch_ingest success
2.5s
test-api-integration tests.test_integration::test_integration_empty_batch success
0.0s
test-api-unit tests.test_unit::test_ingest_valid_and_invalid success

Prioritized findings (7)

critical
WAKE-003
~2m 13s potential savings

Monorepo cascade: every commit runs ALL jobs regardless of what changed

Detected 4 distinct packages/components, yet 9/9 CI jobs have no `rules:changes` or dynamic affected-target planning. Editing a UI file triggers unrelated backend builds and tests.

Remediation: Use `wake plan` with GitLab Dynamic Child Pipelines (`trigger:include:artifact`) to deterministically run only packages affected by the git diff on MRs, while keeping the full suite on merge trains / main.

  • Detected packages (4): packages/api, packages/shared-schema, packages/web-ui, packages/worker
critical
WAKE-005
~1m 02s potential savings

Nix jobs appear to build on cold stores without a binary cache proxy

Jobs build-nix-env invoke Nix without referencing an internal binary cache (`attic`, `cachix`, `extra-substituters`). Ephemeral Docker GitLab runners lose `/nix/store` on every run, causing massive rebuild cascades.

Remediation: Deploy an internal Attic / HTTP binary cache proxy next to your self-hosted GitLab Runners and configure `extra-substituters` or persistent `/nix` runner volumes.

  • build-nix-env: Nix detected, no binary cache reference in script
high
WAKE-001
~2m 49s potential savings

Lint & format checks run AFTER heavy build/test stages

Jobs lint-and-format run in late stages (lint) instead of failing fast in stage 'build'. Developers wait through full builds only to fail on formatting.

Remediation: Move formatting, linting, and typechecks into a dedicated first stage (or add `needs: []`) so trivial errors fail in <15 seconds.

  • lint-and-format: stage='lint' (position 4/4), needs=[] not set
high
WAKE-002
~42.0s potential savings

Sequential stage barriers block independent jobs (missing `needs:` DAG)

5 of 9 jobs rely on strict stage barriers without `needs:`. Every job in a later stage sits idle waiting for the single slowest unrelated job in the previous stage.

Remediation: Convert stage barriers into an explicit `needs:` DAG (or let `wake plan` emit a dynamic child pipeline DAG per MR).

  • Stages: build -> unit-test -> integration-test -> lint
  • 5 downstream jobs have empty `needs:`
high
WAKE-004
~40.8s potential savings

Missing or non-lockfile-hashed CI caching causes repeated rebuilds

Jobs either lack dependency caching or use broad branch/global cache keys instead of lockfile-hashed `cache:key:files` (or a local runner registry/binary cache).

Remediation: Pin `cache:key:files` to lockfiles (`uv.lock`, `package-lock.json`, `Cargo.lock`), use `policy: pull` on test jobs, and mount a local MinIO/Attic/Nix binary cache on self-hosted runners.

  • Static/branch cache key (causes cache thrashing or stale invalidation instead of `key:files:`): build-nix-env (global-shared-cache), build-api (global-shared-cache), build-worker (global-shared-cache), build-web-ui (global-shared-cache), test-api-unit (global-shared-cache), test-web-ui (global-shared-cache)
medium
WAKE-008
~1m 21s potential savings

Over 40% of job runtime is spent on container prep/cache overhead (not running code)

4 job(s) spend more than 40% of their execution time pulling images, cloning git sources, or zipping/unzipping caches.

Remediation: Switch to pre-baked slim Docker images cached on the runner host (`pull_policy = if-not-present`), enable shallow `GIT_DEPTH: 1`, and stop caching directories with tens of thousands of tiny files.

  • build-nix-env: 95.8s overhead / 102.8s total (prep=88s, git=2s, cache=2s)
  • build-api: 13.5s overhead / 24.0s total (prep=5s, git=2s, cache=2s)
  • build-worker: 14.4s overhead / 23.9s total (prep=5s, git=2s, cache=2s)
  • test-api-unit: 10.6s overhead / 21.8s total (prep=2s, git=2s, cache=2s)
medium
WAKE-009
~8.1s potential savings

Top 2 slow tests account for 59% of total test duration (11.5s)

A tiny handful of slow tests dominate your test suite runtime. These are prime candidates for `wake optimize` (root-cause diagnosis of sleeps, repeated DB/fixture setup, or unmocked I/O).

Remediation: Run `wake optimize` to inspect these test files with your self-hosted LLM and generate targeted speedup patches, or split them into a dedicated parallel shard.

  • tests.test_integration::test_integration_polling_retry — 6.50s
  • tests.test_worker::test_worker_large_window_simulation — 5.00s