QA dispatch surface
Dispatchable suites are bound to a CircleCI job and the self-hosted runner. Graph-only suites come from the semantic index (behaviour/test catalog) and have no CI binding — inspect them or run their tests from Tests.
Multi-actor, op envelope, lock, batch, and persistence contracts. This lane proves cross-client invariants and API/browser parity on the self-hosted runner.
CVL editor and Node-tree micro-contract proof. The intentionally excluded flaky micro specs remain outside this dispatch lane until their handler timing is repaired.
Dashboard, kanban, sorting, and view-rule browser proof. This lane protects the main user work surface while staying pinned to corbet/unraid.
Linux desktop bundle build and GitHub Release publish from a desktop-v* tag.
Typecheck all workspaces, audit story coverage, refuse unbounded paid providers, enforce the flakiness budget, and run the workspace unit and contract tests under the fast-suite wallclock budget.
Enforced performance budgets for the UI. This lane depends on browser_qa in CircleCI and runs the perf budget suite with the CI multiplier.
Routine browser proof for the most important local development loop. This is the standard browser QA gate and runs only on the corbet/unraid runner.
Realtime, mirror, export, and read-only browser proof. This lane validates collaboration-adjacent browser behaviour without leaving the self-hosted runner.
Prove the Unraid runner can claim and execute a tiny CI job before any expensive or long-running QA lane is dispatched.
Cargo check/test for adapter crates and the desktop shell.
Workspace smoke, origin tracking, persistence, settings, routes, status, and agent surfaces. This is the broad lightweight browser lane on corbet/unraid.
Story-focused browser specs tied to the behaviour catalog. This gate keeps the story-to-test translation honest while staying runner-only.
These suites either have no CI binding or are blocked by the current runner/provider gate. Open each suite to inspect its tests and evidence.
Proof set for User pastes 1 MB of plain text into a single bullet
Proof set for Two agents enqueue same `request_id` concurrently — exactly one row created
Proof set for URL hits free-tier CF quota mid-day — service degrades gracefully, not 1027
Proof set for Hostile collaborator deletes the entire CV quarry from the link
Proof set for User attaches a malicious / corrupt PDF as a reference upload
Proof set for Agent floods workspace with 10k job.create ops
Proof set for User pastes HTML/script tags into description
Proof set for User submits a URL containing weird unicode
Proof set for LLM returns prompt-injection that tries to rewrite FIXED-tier name
Proof set for Agent submits op with `kind` not in op catalog
Proof set for Agent submits op with stale `OP_CATALOG_VERSION` — rejected with version mismatch
Proof set for Agent retries a write 100× with same opId — only first commit lands; others dedupe
Proof set for User opens a workspace ID that doesn't exist — clean error, no crash
Proof set for User opens a workspace with corrupted sub-doc bytes — graceful surface, doesn't poison healthy sub-docs
Prove that CareerVector's invariants hold under hostile or degenerate inputs: oversized pastes, raw HTML/unicode in descriptions, prompt injection aimed at FIXED-tier nodes, unknown op kinds, stale catalog versions from old clients, opId retry storms, nonexistent workspaces, intentionally corrupted sub-docs, concurrent deterministic request_ids, Cloudflare 1027 quota exhaustion, hostile collaborator wipes, corrupted PDF uploads, and bulk-job flooding. The suite is the operational expression of P4-P5 + the §22 quota policy.
Prove that agents and headless MCP clients integrate cleanly: writes flow through the same op envelope (actorClass="agent"), cells tint by provider on the dashboard, the human-write-protection gate rejects agent overwrites of human-set fields without force=true, cardinality is enforced on variant pools unless explicitly overridden, FIXED-tier nodes are never modified by the LLM regardless of model behaviour, and the entire pipeline (extract → enrich → evaluate → tailor) runs through the CF Worker fallback when no browser is present. Includes the deterministic request_id contract that makes headless tailoring idempotent.
Prove the API surface that agents and headless MCP tools rely on stays in step with the browser pipeline: the parity smoke spec exercises every documented op against /api/workspaces, the cutover spec walks an imported legacy workspace, the job-ad role boundary spec pins the public/role split, and the human-cooperation spec confirms agent writes do not race or shadow human edits.
Guard the archived auth-bearer + careervector-auth spike snapshot: the bearer-only middleware core, its Hono integration, and the passkey-only careervector-auth Worker entrypoint. None of this runs in production today; the suite pins the exit state so the design is recoverable.
Pin the @cv/graph library used by the QA platform graph projection: annotation builders, the nine-hub ontology + edge registry, Cypher emission for Falkor merges, heat propagation, neighbourhood traversal, source-backed grounding rules, and the QA + ops graph projections. These tests guard the graph contract the qa-platform endpoint exposes.
Pin the pure-function surface of @cv/domain: the LLM cascade (resolver, seed/consensus, chain-config loader, callWithChain, model catalog, AI LED), salary extraction repair, cell-origin and audit projections, scoring + hard-fact normalization, views rule engine, columns + order + import/export, locale + language helpers, scrape URL normalize, Google Maps directions wrapper, the singleflight compute lock, protected-fields gate, pipeline stage executors + xstate machine, BYOK key helpers, workspace settings helpers, ruler/measure source (with optional typst CLI integration) + fragment cache, font fallback registry, node-to-typst + preview-segments, jobcache row builders + workspace read chain, Zod schema defaults, gateway sinks, slug ID bookkeeping, industries enum, translate, and the cross-bundle equivalence check that catches bundler drift.
Pin the typed op catalog and Yjs apply runtime: job.* / node.* / tailored.* / selection.update / translate, cvl.* action expansion into batched sub-ops, the unified batch primitive (single-sub-doc collapse + cross-sub-doc atomic dispatch), variant-pool wrapper transparency, Y.Text seeding for collaborative prose, multi-tab CRDT convergence fuzz, validate gate, migration id collision repair, and fast-check property invariants for the recursive Node tree.
Prove the CareerVector ops + status workers honour their wire contracts without a live D1: the telemetry-tier gating on GET /workspaces/:id degrades correctly on expired/unbound projections, the services/finops/ status rollups never leak secret tokens, the /graph/ops projection emits only the nine canonical hub kinds and rejects behaviour→infra shortcuts, ops-mcp + status-mcp forward 1:1 to their API workers inside the admin boundary, the status api returns the public projection shape with no admin bindings, and the CORS contract only echoes the status.careervector.corbet.ch origin. The typed UI clients pin their production base URLs and request shapes.
Pin the QA platform wire contracts: behaviour search uses MATCH without D1-hostile bm25(); suite dispatch plans one proof set at a time and audits dispatch requests; the CircleCI pipeline params only emit only_job + bypass_fast and the allowlist forbids legacy synthetic qa.* names; reconciliation polls workflows/jobs and writes workflow_runs/workflow_jobs; ingest produces a stable workflow_id and chunks D1 batches to ≤90 statements with INSERT OR REPLACE idempotency; the tests catalog search + facets and Investigate change-selection seed paths are pre-AI; and the qa-mcp worker forwards 1:1 to the same REST surface inside the outer admin boundary with the documented upstream-failure mapping.
CareerVector user-story tests under ui/e2e/stories/ that previously each lived in their own singleton suite. Covers solo-applicant edge cases (industry-not-in-enum, missing home address, manual job reorder within group, peer CV/CL trees across languages, terminal-status auto grouping, read-only view link, quarry node activation, CV summary edit) and the agent-operator MCP "add job by shape" probe.
Broad CareerVector browser e2e: dashboard table, kanban board, views with group reorder, routing, layout (incl. zoomed), keyboard navigation, BYOK key entry + chain resolution, realtime collaboration over the canonical Y.Doc relay, synthetic workspace lifecycle and cleanup, MCP dispatch from the browser, profile/notes persistence, read-only workspace views, status centre frugality, perf smokes, and the import-to-tailor synthetic journey. Acts as the catch-all e2e gate for ui/e2e/*.spec.ts that is not story-, perf-, or persistence-scoped.
Vitest gate for pure-logic helpers under ui/src that previously each lived in their own singleton suite: DnD action helpers, profile-stack Node-tree extraction, JobImport modal parsing, the service-worker sub-doc SWR cache, and the live-capture e2e helper.
Pin every reader that powers the cockpit surfaces: the claim-mix readout, the compute-lock contention summary, per-provider activity, the queue mix, recovery activity, and workspace rollups. The cockpit tabs depend on these projections matching their schema exactly.
Walk the cross-cutting story scenarios that span pipeline + collaboration: three actors converging after an extract, adding a column mid-score, switching the view group mid-drag, friend-edits during a tailor, the agent-tailors-while-user-offline path, mid-tailor section adds, and the no-workspace-delete safety. These specs catch races that single-actor suites cannot see.
Pin the @cv/importer translators and the cutover planner: cell-origin and files translation, jobs and settings projection, the plan-workspace-cutover readiness scorer, and the dry-run integration that walks v1 + v2 SQLite snapshots without writing to D1.
Pin the @cv/server library surface: the actor-id round-trip used by every op envelope, the changes-stream broker that fans out SSE, the compression helper for sub-doc snapshots, the dispatch-fallback adapter shell, job records + jobcache commands and lookup, key entitlements, LLM error classification, the mirror writer, the process-request claim and lease flow, score recompute, stage attempts ledger, workspace ops, and the workspace sub-doc split commit path.
Pin the CVL editor's UI integration: the workspace SDK migration that routes CVLEditor + list editors through @cv/workspace-client, and the Y.Text binding helper that backs every collaborative prose field.
Pin the dashboard UI surface: the commute API client called from the Commute tab, the workspace SDK migration covering Dashboard.svelte + JobDetail subtrees, and the resolved-records projection consumed by the dashboard route loader.
Pin the synthetic journey lane in the UI workspace: the synthetic-evidence harness walking the whole pipeline against deterministic fixtures, plus the jobcache-mock that supplies fact rows so the lane never talks to a real provider.
Pin the per-job xstate pipeline driver in the UI: the normalizers that shape stage inputs and the routing layer that picks the right consumer + capability when a stage fires.
Pin the UI realtime channel: the changes-stream SSE client, the WebSocket connection implementation with relay-walker failover, presence, the green console diagnostic, the SDK bridge that joins client SDK + connection, and the tab coordinator that elects a leader for SSE wake.
Pin the SvelteKit server-side helpers in ui/src/lib/server: the chain-availability loader that surfaces provider readiness in the toolbar and the process-commands helper that proxies into the api worker.
Walk the CVL editor end-to-end: agent + human cooperation, bullet reorder across panes, edit latency, micro-interaction polish, full-list reorder, the header drag chip layout, and the export path. Catches Svelte hydration regressions and CRDT merge ordering bugs the unit tests cannot.
Pin the Loro CVL engine experiments under experiments/cvl-engines/loro/ and experiments/cvl-engines/loro-extended/: the engine adapter unit tests and the shared-fixture bench. Outputs feed the cvl-engine-bench-reports contract.
Pin the Yjs CVL engine experiment under experiments/cvl-engines/yjs/: the engine adapter unit tests plus the bench harness. Outputs feed the cvl-engine-bench-reports contract.
Pin the in-memory baseline engine that the cvl-engines bench compares Loro/Yjs against: the engine unit tests and the local-cvl-bench harness.
Pin the known CVL editor bugs we are not yet ready to fix but refuse to let regress: layout/zoom overflow, two-tab sync divergence, and multi-tab reorder ordering issues. Failures here mean the bug got worse, not that it is unfixed.
Prove the quarry-to-tailored pipeline end-to-end: FIXED identity passes through verbatim, HYBRID selection picks job-relevant entries without fabrication, OPEN sections stay factually grounded, the LLM cascade falls over on 429s and exhaustion, snapshot/promote preserves quarry variants, and locale conventions resolve per job.
Pin the dashboard table end-to-end: column reorder, modal flows, table edge cases, form validation, deep job detail tabs, and the jobs + scoring path. Covers the main product surface where most users live.
Proof set for Default quality run spends no budget
Proof set for Fast checks stay fast enough for local loops
Proof set for Slow free checks stay repeatable
Proof set for Browser smoke proves the app without provider spend
Proof set for Release gate starts from zero-budget evidence
60 of 229 suites