Validation

Native Git bundle qualification uses synthetic repositories and scripted providers, never a live project: tests/config/classic-git-materialization.test.ts compiles and binds the selected roles/correction nodes and custom overrides; the packaging tests verify standalone source/output prompt closure. tests/cli/init-provisioning.test.ts exercises public fresh commissioning and byte-unchanged retained init. Native Supervisor/correction tests and cache-suffix regressions cover different boundaries, not a substitute for fresh first Run, startup cancellation, reset-before-delete, checkpoint invocation, actual browser evidence and full release gates. Static renders prove selected text/contracts, not model understanding or behavioral improvement.

The 2026-10-27 native Git qualification passed functional constituent gates: 390 backend suites (5134 tests, seven snapshots), 11 terminal-child tests, 32 E2E suites (147 tests), six compiled quality programs, and UI qualification (836 unit, 11 smoke and 48 browser tests). This is not a literal aggregate release pass: the initial parallel release failed, and the subsequent monolithic serial backend exhausted the Node heap. Passing serial batches do not erase those failures. Separate security checks returned root exit1 for the known high Zod advisory (deferred, unwaived) and web exit0. These synthetic source results do not establish live adoption or exact-SHA public publication.

For resource-constrained native-Git qualification, use the existing Jest CLI control: npm run test:parallel -- --runInBand tests/runtime/actors/supervisor-native-correction.test.ts. The package has no worker-limit environment variable; arguments passed to the top-level release script do not propagate to its nested Jest command. To execute the backend release stage serially, run npm run check:stamp-producers, npm run test:parallel -- --runInBand, and npm run test:terminal-child, retaining all other release stages separately. Report this as constituent release gates, not an invocation of the unchanged aggregate command. Native operation deadlines and all repeated-preservation/source assertions remain unchanged; resource contention can trigger real containment, which must not be treated as success.

web:test:operator-smoke includes native-git.spec.ts: public classic-git init, actual server/local scripted providers and real Git delivery, correction and terminated-command browser evidence. The full retained transcript may conservatively protect all work during GC; that scenario verifies zero effects and unchanged selected captures/index/ref, not selective collection. The owning tests/workspace/work-garbage-collector.test.ts separately uses fresh public commissioning with empty configured conversations/minimal bootstrap records, actual sequential bootstrap captures and a strict-valid incomplete native artifact selection to verify selective retention plus deletion of an unselected control. Neither witness changes GC reference interpretation or certifies model compliance.

tests/cli/native-public-lifecycle.test.ts exercises the selected native bundle's public reset collision-before-delete/fresh namespace, rootless no-replay refusal, startup create-runtime, OS-signal containment, and subprocess-injected publication and process-group observation fatal boundaries. tests/e2e/native-public-first-run.e2e.test.ts starts from public CLI commissioning and uses the actual server/Analyst/Planner/ Executor paths with a local scripted HTTP provider. It checks strict empty checkpoint arguments, natural hook-descendant settlement and Stop during checkpoint, including exact tool pairs and the owning conversation's observation suffix. Interrupted native evidence can end with an unmatched process start: retired authority does not invent a completion or continue Git commands. These bounded witnesses do not replace the full publication-frontier, prompt-reentry or browser/release matrix.

The bootstrap lifecycle suite also distinguishes pre-effect failures from post-publication uncertainty at session, execution, record, artifact and head boundaries. Its subprocess fault injector checks for forbidden follow-up filesystem and signal calls. First execution evidence is a fresh replacement publication: failure writing its unselected temporary file is not canonical uncertainty; the uncertainty witness fails after its selecting rename. Native preservation tests interrupt after naturally settled normalization/abort, while Supervisor tests cover ordinary snapshot-selection failure and Stop after actual snapshot publication. These are bounded witnesses, not every possible timing interleaving.

The existing publication-fatal child harness additionally runs public-commissioned native projects through actual Supervisor checkpoint and delivery. It injects uncertainty after source-head rename and after parent delivery-head rename, before child facts can be selected, checking no later filesystem/signal/runner calls, abort-listener release, gate transition or parent continuation. Its separate known head-open failure retains one factual delivered execution without publishing child DONE or replaying delivery. These subprocess witnesses retain their scratch receipts.

Native quality witnesses require explicit SAIVAGE_QUALITY_NATIVE_ROOT provisioned from the tracked exact qualification inputs, NODE_DISABLE_COMPILE_CACHE=1, and a matching build before tests/quality/native-engines.test.ts. The Jest test launches the built standalone Node harness; missing prerequisites fail rather than skip. Run node dist/tests/scripts/quality-actions-smoke.js with that root and explicit SAIVAGE_QUALITY_TEST_SCRATCH to exercise all three real compiled actions and optional global tools through the same finite owner without providers. See the qualification limits; this smoke alone does not certify record acceptance, browser navigation or external authentication.

validate:release additionally requires npm run test:quality:compiled after the matching build. It runs the standalone native semantic tests, actual actions and selected external-tool surface, then nine production NodeExecution cases (clean, findings, native-config error for each language). The latter holds deterministic local assessment before completion and inspects accepted current/history evidence, ordinary assessment input, authenticated operator API and exact Files artifacts. No paid provider or substituted positive analyzer is used. Set SAIVAGE_QUALITY_TEST_SCRATCH to an existing absolute scratch directory as well.

The browser smoke suite includes real typed-quality clean/findings record/history, execution and work-link navigation using the built runtime. A matching build and the same explicit native environment are required; absence fails, never skips. These tests do not by themselves prove full MCP authentication, process-edge fault handling or independent reviewer quality.

The compiled suite also runs quality-global-smoke against real authenticated MCP and internal Analyst HTTP ingress, including strict-empty/subset rejection before any launch, distinct configured policy scopes, body-free receipts and no global card-log/record authority. Client disconnect retains accepted external work; owner shutdown cancels and joins it. A card-agent tool call in the production fixture analyzes a different bound scope from the following action. quality-process-edges uses actual native-helper process groups for timeout and cancellation with a deliberately slow native config/descendant, and deterministic fault injection only at spawn/capture/cleanup/fatal boundaries. The separate production interruption witness checks timeout report acceptance versus cancelled no-acceptance and no assessment. These are executable checks, not promises of a passing run or independent model review quality.

The positive quality production fixtures additionally enter a separate configured Reviewer node after assessment. A premature approval is rejected by the ordinary updated-review-record gate; the deterministic provider then reads the accepted native report, writes its own scoped review and submits approval. A held point after that read proves that native clean/findings and Planner assessment cannot complete the fixture before Reviewer acceptance. This is runtime gate evidence, not a claim of independent human-quality judgment. Set SAIVAGE_TEST_COMPOSITION_EVIDENCE to a task-local directory to retain actual quality card/assessment/Reviewer and internal Analyst provider requests plus the authenticated external MCP tool schema for the separate composition review. After building, npm run test:quality:reentry additionally requires that evidence directory and the same native prerequisites. It exercises one real typed-findings case through completed/stopped execution, supported Analyst reopen, separate Run, new action output and held assessment, then ordinary Reviewer acceptance. It checks fresh invocation/activation identity and version-2 context while immutable version-1 evidence stays unchanged. This is distinct from correcting a premature result in one activation; actual captured wires still require a separate final review.

The backend-jest-build and browser-smoke CI jobs pin ubuntu-24.04 (x64) to match the published Python3.14.4 setup-python artifact, rather than a moving ubuntu-latest image. Both explicitly provision a fresh isolated native tree outside the checkout with unchanged Node24.22.0/npm11.19.1 and Python3.14.4, the tracked npm lock and hash-checked Ruff wheel. Provisioning is contributor/CI setup, never a runtime dependency download. CI uses Ubuntu GNU /usr/bin/timeout for finite provisioning/native runs; local workspace operations use the verified GNU /usr/bin/gnutimeout path. Local validation never implicitly installs tools.

Isolated native quality prerequisites

The optional native quality qualification reference owns exact isolated ESLint/typescript-eslint/TypeScript/Ruff inputs, license scope, provisioning and native fixtures. This is prerequisite work, not runtime analyzer availability or a replacement for root lint/tests. Native basics, refined no-cache and extra scope/source-write checks passed under manager qualification. The reference records the original failures and observed limits. The standalone qualification/trace procedures remain separate from routine Jest. Product native checks run through test:quality:compiled in release validation and the applicable CI jobs described above; no skipped native check counts as success.

Optional native source observations

Focused source tests cover strict input contracts, safe preparation, actual HTTP catalog-root joins, channel failures, caller filtering and redaction. These are not native semantic-quality evidence. The implementation manager separately runs the actual prepared engine/watcher argv with exact pinned922921 binary and local MiniLM assets in a disposable workspace, retaining direct owned child handles and independent bounded cleanup. Validate initial docs/code/skills, nested scopes, empty-root population, subsequent events, actual inferred neural capability and lexical-only limits, then list/query/original read through the product tools. Include a classifier-justified short-line documentation file with actual native text and no body/impl, privately retained mapping/provenance evidence, and a watched edit through the real tool/read path. Controlled HTTP tests separately cover carrier election/fetch/impl→body→text projection, metadata loss in both destination orders, redaction-before-caps and the real15s whole-query deadline at catalog/mapping/search stalls without borrowing a caller timeout. Retain abort regressions. Excerpts remain file-level references with unavailable coordinates; joined/capped line windows do not establish exact source ranges. No handbuilt production indexes, synthetic vectors, live services or universal small-file semantic claim. Require browser checks for named result navigation and actual composed-tool review across affected roles/profiles after the last edit.

Choose checks by the owner and risk of the change, then interpret their evidence at that scope. This contributor reference owns commands, prerequisites, CI applicability and specialized comparison recipes. README is the short selector; package scripts and the CI workflow are executable authority. No validation result authorizes deployment, provider spending or state adoption.

Select a profile

Run from the repository root with Node >=24 <25, npm >=10 <12; prefer the latest supported Node 24 LTS patch. Install both root and web dependencies, including development and native optional packages:

npm ci
npm --prefix web ci

A fresh dual install is required in CI and dependency comparisons, not before every ordinary local command. Root/web installs are real prerequisites for npm run check:export-consumers, lint and routine. Browser checks additionally need the selected browser, host libraries and their fixture/network prerequisites.

Profile	Actual composition	Does not establish
npm run validate:docs	docs:verify: docs build and guards, including fixture-backed operator API Jest	Full backend Jest or operator smoke
npm run validate:routine	Typecheck, export-consumer guard, canonical-persistence drift, in-band tests/architecture Jest, docs verification	Full backend Jest, lint or production web build
npm run validate:ui-smoke	Operator cockpit Vitest and explicitly selected operator Playwright specs	All web Vitest or all browser specs
npm run validate:ui	Web typecheck, complete web Vitest, operator smoke	Full backend or complete browser profile
npm run validate:release	Typecheck, full build, canonical npm test, backend E2E, operator smoke, docs verification	Independent security gate, exact-SHA CI or live deployment

Also select npm run lint, npm run audit:security and npm run deps:review where applicable. Release does not run/replace the separate high/critical audit. The current lint script runs export and stamp guards, ESLint, import-boundary tests, web-component boundaries, reachable-browser imports and npm run format. The latter is a Prettier check, not a rewrite, on src/ with shipped prompt trees excluded by the existing ignore policy. Prompt bytes are authored deliberately; build checks their packaging and composition. Independent guard order is not a cadence contract; required coverage and fail-propagating composition are.

Select focused owners first

Changed owner	Focused check / follow-through
Backend behavior	npm run test:direct -- --runInBand --runTestsByPath <test-file> or npm run test:parallel -- <Jest arguments>, then appropriate broader profile
Backend E2E	npm run test:e2e (separate from ordinary Jest)
Real terminal child	npm run test:terminal-child, independently when investigating cleanup/runner changes
Export or backend boundary	Semantic export test, export CLI, npm run test:import-boundaries, full npm test; routine alone is insufficient
Shared browser-facing root	Reachable-browser guard, web build and actual root-consuming mounted/browser tests as well as backend checks
Documentation guard	Its malformed/missing/negative regression cases plus final docs verification; link success is not prose accuracy
Server plugin	Real backend socket/application-composition tests, affected errors/cleanup, routine and build; mocked browser sockets do not cover it
Vue/compiler, parser/sanitizer, dev tools	Dependency comparison recipes, then applicable profiles

Keep natural exits, exact commands, source/lock identities, toolchain executable, versions, warnings and artifacts. A timeout is incomplete evidence, not a pass. Use finite external bounds for experiments; if a tool adds an outer deadline, give it room beyond the inner timeout and kill grace. Never force-exit, suppress failures, weaken assertions or retry until green. Required candidate failure still blocks acceptance if baseline fails too.

Backend execution and terminal ownership

npm test is the complete non-E2E backend authority: its pretest checks stamp producers, then ordinary parallel Jest exits before the exact terminal-child suite runs serially. test:direct and test:parallel use the ordinary selection, excluding Playwright, backend E2E and terminal-child. test:e2e owns backend E2E separately. The .cjs import ratchet is Node-owned, not a Jest suite.

Jest 30 uses ts-jest ESM and Node's experimental VM modules. The scripts set NODE_OPTIONS=--experimental-vm-modules; direct Jest must do so too. Explicit JS/TS testMatch families are **/__tests__/**/*.[jt]s?(x) and **/?(*.)+(spec|test).[tj]s?(x). TypeScript transforms retain useESM:true, inline ESNext/NodeNext/isolatedModules, .js-relative mapping and enabled diagnostics. Isolated transforms do not replace strict tsc --noEmit semantic checking.

workerGracefulExitTimeout:5000 is a finite, concurrent worker-shutdown allowance, not a test/hook deadline or speed target. No forceExit option is enabled. Jest's own fallback may warn about an overdue worker; complete canonical stages with natural npm exit 0 pass even with that warning. No warning is not proof of leak-free cleanup or attribution of a past teardown fault.

Terminal ownership and deadlines

tests/boot/app-terminal-child-process.test.ts launches fixtures directly through Node --import tsx, not the tsx CLI or tsx/esm. The signal fixture emits a full READY:<pid> after App startup; the test requires that PID to equal the spawned PID before SIGTERM, then requires exit 0 with no signal. Labelled complete output and exit/signal are retained before assertions; spawn failure or close-before-READY rejects immediately. Deadline teardown retains partial output.

Explicit 30-second harness cases cover heavy setup/settlement/cleanup, not product latency or a global multiplier:

Test owner	Protected path
tests/e2e/reviewer-rework-feedback.e2e.test.ts	Same completed child reopened for reviewed correction
tests/e2e/specialized-card-type-flows.e2e.test.ts	Review/redraft cycles and final immutable review evidence
tests/e2e/failed-child-activation.e2e.test.ts	Failed-child admission rejection and sibling natural settlement
tests/e2e/urgent-summary-cancellation.e2e.test.ts	cancel and distinct_failure evidence, queue effects and joined cleanup
tests/tools/project-file-tools-read-limits.test.ts	1002-file packing and oversized-item byte pagination
tests/tools/view-image.test.ts	Exact 40M-pixel 2000×20000 normalization and adjacent hard-cap rejection

Inner polls, semantic assertions, application timers and fixture limits remain independent. ProcessRunner's losing-wait timer retirement has focused timer and natural-exit regressions; it is not proof that all teardown faults were fixed. Subprocess intermediate-state tests hold progress at local gates instead of racing a timed exit: process-provider.test.ts uses captured-byte readiness, and its split-write/process-inline E2E gates release after running assertions, including controlled 750 ms observations. Finite waits still bound hangs; owner cleanup and terminal retirement remain required.

Source and persistence guards

Export-consumer guard

npm run check:export-consumers is the singular semantic external-consumer guard, without a scope selector/alternate phase. Candidates are tracked non-test, non-declaration TS-family src/**/web/src/** modules and non-test web Vue SFCs. Consumers include all tracked TS-family files (declarations/out-of-config tooling included), web SFCs and JS-family files. Effective SFC defaults, explicit ordinary exports, exact emitted dist/src/**/*.js and canonical browser /src/<path>.ts mappings participate.

Explicit compiler-semantic references include type/declaration contexts; each barrel or re-export route stays distinct. Production/test-consumed TS exports seed an additive, in-memory candidate-owned emitted public/protected declaration closure; an unconsumed outer export cannot rescue dependencies. Production outranks test reachability. SFCs are semantic owners/consumers but do not originate declaration units/emitter-only edges; web typecheck is their authoritative type gate.

Reported classes are production-consumed, test-only, local-only and zero-use. Local-only/zero-use, stale/unresolved edges and unsupported forms fail. The strict scripts/export-consumer-allowlist.json remains empty. For sorted test-only output: node scripts/check-export-consumers.js --report-test-only.

Computed imports remain unsupported except the exact source-owned loadModule function in src/quality/eslint-analysis.ts: it loads operator-provisioned native packages outside the repository export graph. The checker matches that complete function's normalized syntax, including resolved entry containment, not the file as a whole or an arbitrary suppression comment. Changes to the loader require reviewing this explicit boundary; changed expressions, other locations and sibling computed imports remain failures. This models export visibility, not certification of operator code or package safety. Browser quality fixtures use a literal packaged module import in a test-local JavaScript loader with source-owned declaration types, so building TypeScript does not ingest its own emitted declarations.

npm run test:direct -- --runInBand --runTestsByPath tests/scripts/export-consumers.test.js
npm run check:export-consumers
npm run test:import-boundaries
npm test

The semantic test independently checks inventory parity, identity/histogram/counter arithmetic, declaration traversal/promotion, cleanup and empty failure sets, plus selected actual SFC consumers. Preserve those invariants and fixture expectations; do not repin aggregate counts or retain obsolete owner examples as compatibility. Update an example only after evidenced intentional replacement, preserving existence, production-consumed classification and SFC consumption assertions.

Import-boundary ratchet

npm run test:import-boundaries owns the checker self-test, real-CLI Node regression suite and repository admission. The baseline pins count and SHA256 of the sorted multiset of normalized source/rule/resolved-target tuples. Duplicate edges remain duplicates. Line movement or equivalent relative/alias/terminal spelling does not change identity. Increases, removals and equal-count substitutions fail; after a reviewed genuine removal compare full before/after multisets, prove subset and update both printed fields together. Any new identity requires an owner decision, even under a lower count. Current baseline is zero, with no surviving exceptions.

The defining checker owns exact public entrypoints, not *-api naming or adjacent/nested leaf permissions. Its one-rule precedence is contracts-declarative → schemas-bottom-layer → redaction-primitive → agents-runtime → runtime-agents → workspace-runtime → server-boot → server-import → cross-package-deep. Specific prohibitions override public surfaces, including type-only/export-from occurrences. Runtime uses persistence/session-api; cross-package runtime consumers use runtime/runtime-api. Agents↔runtime, workspace→runtime and server→boot remain forbidden. Redaction primitives may reference only schemas/contracts across packages. The exact server-only schemas/round-id-server entry is not a schemas-wide exemption and is not exported from the browser-safe schemas root. Same-package leaves remain allowed.

Diagnostic components are node scripts/check-import-boundaries.cjs --self-test and node scripts/check-import-boundaries.cjs, not extra maintained profiles. The Node regression covers precedence, duplicates, substitutions, line movement, exact entrypoints and direct projector/type-only denials. Admission proves neither cycle freedom nor complete syntax coverage; execute routed semantic owners too.

Canonical-persistence drift guard

npm run check:canonical-persistence-drift supplies bounded lexical hints against retired card/record index authority. Established conversation indexes and empty catalogs remain legitimate. Semantic source tests and review independently own persistence correctness and migration authorization; word detection neither bans affirmative external-migration prose nor certifies consent.

Documentation, build and static serving

npm run docs:verify builds VitePress then checks ignored dist policy, route/debug/ tool/config inventories, heading-scoped value contracts, architecture links, historical isolation, fixture-backed operator API responses, global Markdown links, README/docs source anchors and validation cadence. See scripts/docs-verify.sh. It does run selected Jest; it does not run complete backend Jest or operator Vitest/browser smoke. The cadence guard structurally parses workflow YAML once, rejecting duplicate keys, and checks command coverage/prerequisites, not arbitrary shell semantics or prose comprehension. Missing/malformed contract negative cases must remain meaningful.

The Markdown guard retains repository-wide file resolution, but published docs fragments and internal HTML links use actual freshly rendered IDs and hrefs, not guessed heading slugs. Missing rendered output is a failure. It checks local pages/assets under the selected DOCS_BASE (default /docs/), including same-page, cross-page, index, encoded and explicit-ID targets. README/repository links into published docs use those same emitted IDs. Repository-only Markdown has a separate GitHub-heading/explicit-anchor check; explicit remote GitHub source links are not treated as local VitePress pages. This is bounded local navigation validation, not a network crawl, browser interaction, search-quality or prose-accuracy proof. The same gate runs node scripts/check-markdown-links.js --self-test: an installed VitePress build in disposable scratch, with positive navigation and deliberately broken fragments, pages, output and prefix checks.

npm run build compiles TypeScript, packages every registered prompt closure, builds docs/web, then runs npm run test:compiled-prompt-composition and npm run test:static-serving. Packaging compares independently compiled classic/ classic-typed shared agent/fragment memberships and bytes, plus common process prompt bytes; typed-only process paths remain allowed. Composition compares source/ package bytes and all five selected roles. Routine does not run these build checks.

Static smoke uses actual Fastify against freshly built assets: /docs redirect, landing/linked pages/resources, CSS/JS/conditional icons, missing docs 404, SPA / and /cards, built web assets and asset/API misses 404 rather than SPA fallback. Root relocation tests additionally exercise missing docs build and unknown routes. Instance docs use /docs/; Pages builds use DOCS_BASE=/saivage-v3/. For a docs-base change, verify both builds' nested links/assets/anchors and direct reloads in a bounded local preview, then restore default output for static tests.

An isolated build may compile production and smoke into one output root, package prompts there and run the copied smoke with --source-root <repository>. That is release-equivalent constituent coverage, not a literal default-profile pass. Never stage generated dist, live/generated runtime state or private evidence.

Native-path script entrypoints

tests/scripts/file-url-entrypoints.test.js invokes actual packaging/docs CLIs in tracked-file relocation fixtures on Linux. Packaging uses installed tsx in ordinary and checkout café paths; the native-Node docs verifier also covers checkout café #?%20%. Each starts from a healthy baseline, then rejects missing selected prompt/public-route drift. Packaging checks exact sets/bytes/closure; distinct-driver and no-argv imports remain silent with invalid fixture inputs.

Run separately from the root (two cases per command):

timeout --kill-after=10s 900s env NODE_OPTIONS=--experimental-vm-modules node node_modules/jest/bin/jest.js --runInBand --runTestsByPath tests/scripts/file-url-entrypoints.test.js --testNamePattern='packaging entrypoint'
timeout --kill-after=10s 900s env NODE_OPTIONS=--experimental-vm-modules node node_modules/jest/bin/jest.js --runInBand --runTestsByPath tests/scripts/file-url-entrypoints.test.js --testNamePattern='docs entrypoint'

Children/discovery use 60-second bounds with 5-second kill grace; each case has a 360-second Jest budget. This does not certify all-platform portability or packaging/full build through combined #?% paths: an observed pre-entrypoint tsx loading limitation remains outside that coverage.

Browser and E2E profiles

npm run web:test:operator-smoke owns cockpit Vitest plus the explicit operator Playwright list in package.json (including independent scroll/selection, card status and external Analyst mode). npm run web:test:e2e:smoke is the complete self-contained browser profile: all preview smoke via web:test:e2e:preview-smoke, then the source browser-client test via web:test:e2e:browser-client-smoke. The first owns production preview; the second owns a Vite dev server. Neither targets a live deployment.

Current locks select @playwright/test, playwright and playwright-core 1.64.1; matched Chromium/headless shell revision 1248/version 156.0.8078.4 and ffmpeg 1013. Refresh browser installation after package changes. External Playwright MCP tooling has an independent pin/contract; system Chrome is another validation choice, not matched-browser evidence.

For opt-in isolated browser-cache assessment, choose an assessment-owned writable absolute path outside generated Saivage state; use workspace tmp/ for harness artifacts. Run both commands in the same shell with unchanged path:

export PLAYWRIGHT_BROWSERS_PATH='/absolute/path/to/assessment/browsers'
unset PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH
timeout -k 10s 600s npm run web:test:e2e:install &&
  timeout -k 10s 900s npm run web:test:e2e:smoke

Do not run smoke after failed install. Restore that exact path in later shells; this does not alter global cache defaults. Host browser libraries may also require npx playwright install-deps chromium under actual installation authorization. For deliberate local system Chrome: PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH=/absolute/path/to/chrome npm run validate:release.

Fixture requirements and evidence limits:

• Real-server helpers bind both disposable project and exact YAML. The restarted cockpit regression supplies conflicting synthetic stale startup selectors through both starts and restores prior env presence/values; it tests intended selection, not missing-config recovery.
• A non-loopback plain-HTTP operator case needs a non-internal local IPv4 interface reachable by Chromium. Missing interface is failed prerequisite, not a skip.
• Preview transport mocks establish rendered behavior, not backend correctness. Route smoke inspects collapsed partial-message qualifiers, selected/full counts, byte coverage and the secondary safe-original disclosure.
• Preview failure observation tolerates only exact same-origin /api/ GET net::ERR_ABORTED; other failures remain asserted absent. It does not prove cause.
• CI failure/cancellation uploads tmp/playwright-report and tmp/playwright-results best effort; absent artifacts warn, not fabricate evidence.

Shared-root exports need actual browser eligibility and consumers:

node scripts/check-web-browser-imports.cjs
npm --prefix web run build
npm --prefix web run test -- src/__tests__/card-store.test.ts src/__tests__/operator-cockpit-smoke.test.ts

Web uses schemas/index and selected leaves; the backend contracts root is not a browser entry. Node typecheck/Jest and Node-externalization warnings are not proof of browser safety.

CI applicability and exact-SHA results

The push-only master workflow uses Node 24, contents:read by default, no GitHub secrets in validation jobs and cancellation of superseded runs. Classifier rules are overlapping, not a single suffix decision:

Changed path	Applicable expansion
docs or Markdown only outside other governed families	Routine/docs; Pages
src, bin, scripts, non-Playwright tests, Jest/TS config	Backend build/Jest, backend E2E, lint
src/contracts or src/schemas	Backend and UI/browser/lint
web or Playwright tests	UI/browser/lint
Root/web manifest/lock	Backend, UI/browser, dependency audit, lint
Workflow or unknown non-doc path; unavailable base/diff	Fail-closed all jobs

For example, a Markdown README under src/ is docs-like but also sets backend applicability. docs_only does not override that flag. Inspect the actual changed paths and classifier output, never infer jobs solely from a “docs” commit label.

Job	Real setup and check
routine-docs (always)	Dual clean install, one validate:routine; included docs:verify is its sole docs gate
backend-jest-build	Ubuntu24.04/x64; dual clean install, pinned Node/Python and isolated quality provisioning, build, canonical npm test, compiled native quality witnesses
backend-e2e	Root clean install, test:e2e; no web/browser/external service
ui-vitest	Dual clean install, web typecheck and complete Vitest
browser-smoke	Ubuntu24.04/x64; dual clean install, Chromium and host libraries, pinned Node/Python and isolated quality provisioning, matching packaged runtime build, complete self-contained browser profile, failure artifacts
dependency-hygiene	Dual clean install, audit:security
lint-guards	Dual clean install, lint
docs-pages-build / docs-pages-deploy	After routine success, root install/Pages-base docs build and separate deployment

Checkout→cached Node setup→installs→their consumers and browser setup→smoke→upload are meaningful prerequisites. Independent installs/setup steps need no incidental relative ordering. Workflow parsing/command recognition supports decoded YAML run scalars, comments, continuations, assignments and established splitting, not arbitrary shell control flow; lexical secret-safety checks remain separate.

validation-required requires successful classifier and routine; every applicable conditional job must succeed and every nonapplicable job must be skipped. Cancelled, pending, failed or unexpectedly skipped applicable jobs are not green. Pages deploy has job-local pages:write/id-token:write and is deliberately outside that aggregate. For publication, verify its conclusion separately. Require the run's headSha to equal the final local/upstream commit, not a green ancestor. Local gates are distinct evidence and do not waive applicable CI.

The two runner pins select a supported exact prerequisite pairing, not a hosted test pass or a project-wide OS support policy. Workflow changes make all jobs, including dependency-hygiene, applicable; the known deferred/unwaived root Zod finding can still block validation-required. Qualifying the runner fix requires both affected jobs to complete their unchanged functional checks, not just setup.

Dependency comparison recipes

Record baseline/candidate source and manifest/lock hashes, actual Node executable, Node/npm versions/architecture, clean-install/peer-tree results, tests, warnings, natural exits and containment. Use independent disposable root/web package roots with npm ci --include=dev --include=optional and successful npm ls --all. Preserve unrelated resolutions; no blanket dedupe, overrides or npm audit fix. Native Sharp import/image-conversion tests matter on the intended platform. Use short writable TMPDIR/caches and isolated no-egress/private-IP fixtures where the comparison requires them; registry install/audit network is separate permission.

Matched Vue core patch comparison

Check both root/web graphs for the intended matched Vue patch and nine core companions, no stranded copies or unrelated churn. Assess necessary transitives. Establish baseline mounted frontend/compiler semantics, then candidate:

npm run web:typecheck
npm run web:test
npm run test:direct -- --runInBand --runTestsByPath tests/scripts/export-consumers.test.js
npm run validate:routine
npm run validate:docs
npm run build
npm run validate:ui-smoke
node node_modules/@playwright/test/cli.js test -c tests/playwright/smoke/playwright.config.ts tests/playwright/smoke/storage-head-history.spec.ts tests/playwright/smoke/conversation-instruction-flows.spec.ts tests/playwright/smoke/operator-image-inspection.spec.ts tests/playwright/smoke/markdown-rendering.spec.ts
npm run audit:security

Retain mounted Records/both histories, observations/compacted context/current and historical instructions, ContextBlock/ConversationTimeline, navigation, primitives/ Dialog/Markdown and actual compiler-consumer assertions. Keep counter arithmetic, not repinned classifications. Use disposable browser fixtures with visible outcomes, console/errors/artifacts, not just launch. Distinguish mocked storage/navigation from real disposable-server image evidence; neither uses a live project. Earlier comparison notes said “Unfilled scaffold — not authored or accepted”; current product terminology is Baseline v0, not a new interpretation of old evidence. No prompt/scaffold semantics change or generated output commit is justified by a dependency test. This scoped comparison does not claim full backend/E2E/release, performance or deployment acceptance.

Scoped ts-jest patch comparison

Locks select ts-jest 29.4.15/Jest 30.5.2/TypeScript 5.9.3. Declared peers permit Jest ^29 or ^30 and TS >=4.3 <7; Node engine includes >=20. Matching major numbers are not required, and peers alone prove no transform semantics.

Compare fresh baseline/candidate installs, specific runner/compiler/transformer trees and unchanged unrelated/web resolutions. Select semantic export, runtime gate/running chain, terminal coordinator/real cleanup and process-runner/registry tests. Run that matrix cold with an issue-owned Jest cache, then export test once warm with the same cache only after cold success. Independently run terminal-child even if ordinary Jest fails, and explicitly select process-inline E2E (override only Playwright ignore):

npm run test:direct -- --runInBand --runTestsByPath tests/e2e/process-inline-output.e2e.test.ts --testPathIgnorePatterns='<rootDir>/tests/playwright/'

Independently exercise the existing config-init consumer in tests/scripts/devtool-security.test.cjs, using the native invocation below. That invocation runs the whole file, including Vite/Babel cases, and needs writable workspace ../tmp plus both dependency trees. For isolated patch measurements, Node's test-runner name filter --test-name-pattern='ts-jest config:init' selects the named config-init case; distinguish that selected result from the full file. Bound experiments with GNU timeout/kill grace; retain semantic assertions, natural exits and proven empty owned cgroups. Do not alter workers/deadlines/diagnostics, suppress warnings or promise timing savings.

Markdown consumer checks

The real consumer web/src/components/content/MarkdownText.vue synchronously parses Marked GFM to a string, default-DOMPurify sanitizes it, then Vue v-html renders it. No hooks/XHTML/IN_PLACE/SAFE_FOR_TEMPLATES/DOM-returning mode is used. Locks select Marked 18.1.1 and DOMPurify 3.4.17; web's sanitizer range remains ^3.4.16.

npm --prefix web run test -- src/__tests__/content/markdown-text.test.ts src/__tests__/card-records-section.test.ts
node node_modules/@playwright/test/cli.js test -c tests/playwright/smoke/playwright.config.ts tests/playwright/smoke/markdown-rendering.spec.ts

Preserve benign GFM/tables/code/HTTPS, Unicode NBSP, encoded Cards links/navigation, literal code references and image/alt retention; reject scripts, executable attributes and plain/encoded JavaScript URLs. Browser coverage includes conversation, full record/Records & History, false execution sentinel and no unexpected requests/ page/API errors, with synthetic transports. Image-element retention is not pixel decode fidelity; no durable source/provenance is rewritten.

For Marked patches run existing cases before/after, then selected Marked patch regression Vitest/Playwright cases independently to establish old failures: literal code-span backslashes followed by emphasis, and an unquoted paragraph as DOM sibling after heading blockquote. Mounted string-parser/sanitizer and browser DOM are complementary. For parser cost observation, use isolated children with external deadlines for '[](' + '\u00a0'.repeat(n), increasing bounded sizes before upstream size 50,000. This is not a timing CI threshold or arbitrary-input complexity guarantee. For sanitizer comparisons retain the same actual consumers/fixtures; publisher nondefault-mode demonstrations are not reproduced Saivage exploits.

Development-tool semantic checks

node tests/scripts/devtool-security.test.cjs
npm --prefix web run test -- src/__tests__/devtool-lifecycle.test.ts --maxConcurrency=2
npm run web:test:e2e:browser-client-smoke

The CommonJS file registers tests with node:test, whose automatic harness runs them when the file is launched directly by Node; it is not a Jest fixture or a retired suite. Node fixtures under workspace tmp exercise actual Vite config denial of direct and resolved-alias access before/after intentional shared imports; Babel rejects outside-package input maps while keeping local/inline maps, and real babel-jest produces usable maps/code. Installed ts-jest config:init renders a fixed template without existing config/--force; evaluate CommonJS with root module resolution and compare usable Node/transform preset. This is not the ordinary ESM transform test. The Chromium client consumes real cards store/schemas/API client with intercepted API, not a live server.

Nested concurrent Vitest bounds beforeEach/body/afterEach by effective maxConcurrency; full web:test also runs ordinary-limit coverage. This is not suite-hook serialization, cross-worker bounds or application ownership proof; retain conversation cancellation/ unmount tests. jsdom does not exercise standalone mocker/browser mode. These Vite/ Vitest/Babel boundary checks are bounded consumer evidence, not root-agent containment or comprehensive security certification.

Handlebars 4.7.10 is transitive through ts-jest: observed use compiles a fixed config template with default options, not untrusted AST/prototype-enabled/inline-HTML rendering. This is not a no-exposure proof or audit waiver. tsx 4.23.15 selects esbuild 0.28.2 within ~0.28.0; Vite's separate 0.25.12 remains. Source-launcher consumers include Node --import fixtures (terminal/publication/public entry/process/logger/ Supervisor), disposable CLI init/repair and prompt copy in build. Registry/copy Jest plus full compiled source/package composition protect that consumer. The Linux transpilation path does not establish applicability of the Windows servedir advisory.

For launcher comparisons explicitly select terminal-child, process-inline E2E and config-init, not just ordinary Jest. Disposable typed-stdin/one-shot SIGINT CLI probes supplement actual App tests: candidate typed output exit 0 and completed async cleanup exit 42, with baseline outcome recorded. No CLI intermediary for App PID, forced exit, relaxed deadline or retry. tsx does not own Jest's ts-jest transform.

Server-plugin maintenance

Use real Fastify REST/auth and TCP-WebSocket admission/observation/inbound-bound tests plus policy/credential-safe serializer coverage, including affected error paths/cleanup. Preserve auth, payload-limit close codes and privacy assertions. Run routine and build (including static serving); mocked browser sockets are not backend plugin validation. Minor-line assessment is separate from security patch acceptance; a passing patch does not justify blanket refresh or runtime workarounds.

Dependency governance and dated evidence

npm run audit:security gates high/critical in both root and web. Both .npmrc files set include=dev, which takes precedence over retained script --omit=dev; effective scope includes dev dependencies. npm run audit:security:all uses moderate. npm run deps:review runs the broader audit and freshness: freshness failure propagates, but moderate/dev advisory exit is reported rather than replacing the required high/critical gate. Review its output, not only its exit.

Run the current package-owned review command separately from the required security gate; it also checks package freshness and may contact package registries:

npm run deps:review

For comparisons run independent root/web npm audit --include=dev --json before and after; use separate high and moderate thresholds where required. Retain natural nonzero exits, severities, affected-package entries, unique advisory IDs/ranges and remediation availability. Aggregate scripts may short-circuit. An advisory absent from the feed cannot be claimed removed from counts by a patch; investigate new findings rather than auto-fix unrelated packages.

Run these separately, preserving each exit even if the preceding command reports advisories (do not chain them with &&):

npm audit --json --include=dev --audit-level=high
npm --prefix web audit --json --include=dev --audit-level=high
npm audit --json --include=dev --audit-level=moderate
npm --prefix web audit --json --include=dev --audit-level=moderate

The following are recorded comparison evidence, not fresh runs by this page, current all-green claims or deployment authorization:

• 2026-10-16 runner: ts-jest 29.4.9→29.4.15 installs/peer trees passed. Each version passed 8 suites/107 tests cold, export 1/44 warm, terminal 1/11, process-inline 1/1 and filtered config-init 1 (three unrelated cases unselected). Candidate routine/build/canonical npm test (333 ordinary suites/4401 tests then serial 1/11) and high audit exited naturally with empty owned cgroups. Root audit exit 1 retained 20 moderate package entries from one sprintf-js advisory GHSA-hp3w-g68c-fv3c; web 0/no findings, no low/high/critical in either. This was maintained-line upkeep, not evidenced local bug/security/performance repair; full backend E2E/release and applicable CI were not certified. Final docs remained a separate required gate.
• 2026-10-16 backend patch: Fastify 5.12.5→5.12.7/static 10.1.3→10.1.6 retained caret floors/exact locks, with only required content-disposition 3.0.0 (Node >=22) transitive change; Node 24.22.0/npm 11.19.1 comparison. The selected affected ranges for Fastify header validation and static path guard were removed; no Saivage exploit was demonstrated (unobserved schema constructs; static advisory's case-insensitive filesystem differs from intended Linux). Both focused inputs passed 8/82 without skips; candidate clean tree/routine/build/ static smoke passed naturally. Independent audits retained root 20 moderate/web 0, no high/critical; selected advisories were not yet in the feed. CORS/WebSocket then remained 11.2.0 pending separate minor assessment. Current manifest now selects WebSocket ^11.3.4; that later selection is not covered by this older claim. Old sanitizer deferral was historical, not current sanitizer disposition. No full release, browser/exploit or unused download-API coverage was claimed.
• 2026-10-17 sanitizer baseline: root 20 moderate affected entries from the same sprintf-js advisory, web 0/no high/critical. DOMPurify 3.4.17 publisher fixes addressed XHTML SVG, IN_PLACE hooks and template/DOM/shadow-root mode demonstrations, not reproduced default-consumer exploits. Publisher latest-release support and a dated pin are not latest-forever/security certification.

The Jest/Istanbul sprintf-js advisory was retained/deferred; upstream repair or compatible parent removal is the revisit trigger. Recheck current audits rather than treating historical counts as current acceptance.

Fixture and evidence discipline

Use os.tmpdir()/path.join and existing mkdtemp prefixes for portable disposable fixtures. Callers may select an existing writable short TMPDIR; workspace harness artifacts belong under workspace tmp/, not live generated roots. Record exact executable/toolchain and locks for comparisons; version strings alone do not identify the executable. Local tests, browser fixtures, static projections and exact-SHA CI are different evidence classes.

The offline compaction fact/action rubric retains frozen observed cases and authored controls, not live quality or changed-model fidelity proof. Optional synthetic packing characterization uses real adapters with synthetic completions over 250/500/1000 small rows and bounded mixed evidence/Unicode/ images:

timeout --kill-after=10s 120s node --import tsx tests/scripts/compaction-packing-characterization.ts

Redirect its JSONL probe/byte/fold/wall/CPU observations under workspace tmp; synthetic waits are separate. It is not live latency, semantic-quality evidence or a timing gate. Deployment/provider commissioning and real tutorial steps need their own actual authorization and cannot be inferred from any profile above.