Skip to content

Validation ​

newloop2 synthetic qualification ​

Under supported Node24/npm (record resolved executables and versions), run:

bash
npm run test:direct -- --runInBand --runTestsByPath tests/config/newloop2.test.ts tests/config/system-template-registry.test.ts tests/cli/init-provisioning.test.ts tests/runtime/actors/supervisor-notification-admission.test.ts tests/runtime/actors/project-completion.test.ts tests/scripts/copy-system-template-prompts.test.js
npm run test:e2e:direct -- --runInBand --runTestsByPath tests/e2e/newloop2-flows.e2e.test.ts tests/e2e/specialized-card-type-flows.e2e.test.ts
npm run validate:routine
npm run validate:docs
npm run build

Set SAIVAGE_TEST_COMPOSITION_EVIDENCE to an external workspace tmp directory before E2E/build to capture actual prepared invocations, compaction projections and every compiled role/node/generated-contract/tool/correction composition. These offline scripted fixtures call real compiler, actor, record, capability, notification and conversation owners, not a test-owned workflow engine or live provider. They cover fresh graph ordering and loops, selective reentry, gates, descendant versus own-record freshness, FAILED versus actual Stop/recovery and uncertainty settlement, parent grants, final notifications, feeds/session reuse, compaction/history, all typed leaves and fresh CLI/package closure. Existing profile parity and specialized/completion regressions remain separate. Inspect complete composed output independently after final edits: tests are not proof of substantive judgment, model compliance or improved output quality. No deployment, adoption, provider pilot or dependency-security waiver is implied; focused success is not aggregate release green.

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, npm run test:redaction-progress, 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. Its correction case asserts a GC preview and deletion of two selected files while checking preserved captures/index/ref and unchanged unlinked evidence. This describes test assertions, not a current run result. The owning tests/workspace/work-garbage-collector.test.ts separately uses fresh public commissioning, compacted configured card sessions, 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/persistence/work-gc-projections.test.ts exercises necessary owner-local decoding and refusal without truncation; tests/workspace/work-garbage-collector.test.ts checks current-selection I/O without old-history reads, compaction horizons, source-aware shell exclusion and retained non-shell inference, including glob thresholds. These are bounded fixture checks, not a performance, security or release-wide guarantee; ordinary consumer validation remains a separate concern.

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.

The ordinary backend selection includes tests/quality/native-engines.test.ts, so complete npm test requires 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 process-edge fixture stages actual PID markers in entered.next.json before renaming to entered.json. Its deterministic incomplete-staging witness preserves canonical absence on first entry and the exact parseable {} sentinel on cancellation entry; the parent reader remains strict. This checks publication isolation, not the uncaptured interleaving of the historical CI failure. Retain failed-run evidence; final qualification requires the matching-build witness and all six compiled programs, plus applicable exact-SHA CI, rather than relabeling earlier results as a green aggregate.

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:

bash
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.

ProfileActual compositionDoes not establish
npm run validate:docsdocs:verify: docs build and guards, including fixture-backed operator API JestFull backend Jest or operator smoke
npm run validate:routineTypecheck, export-consumer guard, canonical-persistence drift, in-band tests/architecture Jest, docs verificationFull backend Jest, lint or production web build
npm run validate:ui-smokeOperator cockpit Vitest and explicitly selected operator Playwright specsAll web Vitest or all browser specs
npm run validate:uiWeb typecheck, complete web Vitest, operator smokeFull backend or complete browser profile
npm run validate:releaseTypecheck, full build, canonical npm test, compiled quality witnesses, backend E2E, operator smoke, docs verificationIndependent 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 ownerFocused check / follow-through
Backend behaviornpm run test:direct -- --runInBand --runTestsByPath <test-file> or npm run test:parallel -- <Jest arguments>; broaden as economical selection and reuse judges the risk warrants
Backend E2Enpm run test:e2e (separate from ordinary Jest)
Real terminal childnpm run test:terminal-child, independently when investigating cleanup/runner changes
Export or backend boundarySemantic export test, export CLI, npm run test:import-boundaries, full npm test; routine alone is insufficient
Shared browser-facing rootReachable-browser guard, web build and actual root-consuming mounted/browser tests as well as backend checks
Documentation guardIts malformed/missing/negative regression cases plus final docs verification; link success is not prose accuracy
Server pluginReal backend socket/application-composition tests, affected errors/cleanup, routine and build; mocked browser sockets do not cover it
Vue/compiler, parser/sanitizer, dev toolsDependency 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.

Inbound Analyst MCP coverage ​

Changes to the external Analyst startup host, listener or request-authority owners use focused direct suites, not a full release run:

bash
npm run test:direct -- --runInBand --runTestsByPath tests/config/analyst-mode.test.ts tests/boot/startup-inputs.test.ts tests/cli/start-command-inputs.test.ts tests/server/analyst-mcp-authority.test.ts tests/server/external-analyst-mcp.test.ts
  • tests/config/analyst-mode.test.ts covers the internal default and rejection, the external/both loopback default, accepted IPv4 and native IPv6 spellings, and rejected hostnames, URLs, brackets, zones, wildcards, mapped IPv6 and padded values, plus unchanged port, token and principal failures. It uses synthetic credentials only.
  • tests/boot/startup-inputs.test.ts covers environment loading: the MCP host comes only from its startup flag, independent of --host, SAIVAGE_HOST and the YAML operator host, with the MCP token kept separate from operator authentication.
  • tests/cli/start-command-inputs.test.ts covers flag parsing, forwarding and announcement of the endpoint returned by a mocked start. It is not resolution or listener evidence.
  • tests/server/analyst-mcp-authority.test.ts injects requests into the listener's HTTP owner without a privileged bind. It verifies that port 80 omits :80 from the derived endpoint and that the exact Host is accepted for IPv4 and IPv6 while localhost and an explicit :80 are rejected. It opens no socket.
  • tests/server/external-analyst-mcp.test.ts uses the real SDK over TCP: a non-loopback IPv4 address with an explicit independent port in external and both modes, and native ::1 with bracketed URL authority and Host. It covers rejected token, Host, Origin, protocol and digest requests, which do not invoke tools, and an occupied port that fails with EADDRINUSE without fallback.

Prerequisites and limits: the real-socket cases choose the first non-internal IPv4 interface found by the test and require native ::1. A missing interface or IPv6 binding fails as an unmet integration prerequisite, not as a skip or substitute. Interface discovery exists only in the test, never in runtime. Loopback-only evidence is not direct host or container access validation. These synthetic local TCP cases do not prove a deployed container address, firewall, client configuration or OpenCode connectivity; those require separately authorized verification.

Economical selection and reuse ​

Select the focused check that covers the changed semantic owners and their risk. That focused check is the minimum, not a ceiling. Full profiles, such as validate:routine, validate:release and the complete npm test, ordinarily follow substantial accumulated work. A model may run a broader set sooner when the risk or a safer preference warrants it. No approval, cadence or justification is required for that choice.

A successful focused check run by a developer or author worker may satisfy the same check for the integrated result when its relevant inputs are unchanged in that result. The role that integrates the result, which is the implementation manager in an issue run, judges that against the final state. It reruns each check whose inputs changed or whose applicability it cannot establish, and it adds an integration check where separately changed owners interact. Reuse concerns executed checks only. It is not a cache, an evidence registry, or a replacement for a distinct prompt or documentation review.

Record each command, its result, its input scope, and whether it was reused or newly run. Unknown applicability is not a pass. Keep failures and timeouts reported even when a later corrected run passes. Named profile and CI requirements, and subject-specific security, authentication and persistence checks, keep their meanings. A focused pass never claims full-release validation.

Backend execution and terminal ownership ​

npm test is the complete non-E2E backend authority: its pretest checks stamp producers, then npm run test:parallel -- --maxWorkers=2 runs ordinary Jest, followed on success by npm run test:redaction-progress and then npm run test:terminal-child, both serial. Failure short-circuits later stages. npm run test:direct and npm run test:parallel use the ordinary selection. Its four exclusions are Playwright, backend E2E, the exact escaped/end-anchored tests/boot/app-terminal-child-process.test.ts, and the exact escaped/end-anchored tests/utils/redaction-key-progress.test.ts. Each isolated launcher selects its own exact file and overrides ignores to exclude only Playwright and E2E. npm run test:e2e and npm run test:e2e:direct own backend E2E separately. The .cjs import ratchet is Node-owned, not a Jest suite. Complete backend execution requires the native prerequisites and matching build.

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.

The six package Jest launchers pass --no-compilation-cache directly to Node for ESM lifetime/headroom, qualified on Node 24.22.0. Use the package commands for equivalent focused execution. This V8 in-process compilation-cache option is engine-specific, not a stable Node application API; unsupported engines fail rather than falling back. It neither disables Jest/ts-jest's disk transform cache nor sets Node's separate disk compile-cache control, NODE_DISABLE_COMPILE_CACHE=1, required by the native prerequisites above. It is not a production runtime flag and promises no memory bound or stronger shutdown guarantee.

Installed Jest workers derive their execArgv from the launching Node process, so the direct cache argument propagates to forked Jest owners. It is deliberately absent from NODE_OPTIONS: ordinary standalone Node children spawned with explicit argv, including the terminal fixture's --import tsx invocation, do not inherit it through their copied environment. Compiled native witnesses run outside these Jest launchers and retain their own invocation policy.

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.

The isolated redaction suite runs fresh and fixed-warm-up child cases with a 5000-ms wall-time assertion after import and warm-up, including assertions and preview hashes. The child has a 15-second startup-inclusive subprocess timeout; each Jest case has a 20-second budget. Bounded classifier attribution can help investigate a failure, but CPU measurements do not replace the wall gate or give a machine-independent timing guarantee.

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 ownerProtected path
tests/e2e/reviewer-rework-feedback.e2e.test.tsSame completed child reopened for reviewed correction
tests/e2e/specialized-card-type-flows.e2e.test.tsReview/redraft cycles and final immutable review evidence
tests/e2e/failed-child-activation.e2e.test.tsFailed-child admission rejection and sibling natural settlement
tests/e2e/urgent-summary-cancellation.e2e.test.tscancel and distinct_failure evidence, queue effects and joined cleanup
tests/tools/project-file-tools-read-limits.test.ts1002-file packing and oversized-item byte pagination
tests/tools/view-image.test.tsExact 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.

bash
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.

Tool inventory verification requires the selected checkout's source, tooling and root configuration, installed root dependencies including TypeScript and Zod, and writable temporary space. It uses a scoped allowJs/noCheck TypeScript project to freshly emit the statically linked JavaScript observer and its TypeScript/JS dependency closure, then executes the emitted observer with native Node. Literal named imports expose its source dependencies to the existing export-consumer guard. It does not reuse checkout dist, require a prior full build, or perform full semantic type checking; npm run typecheck owns that separately and routine runs it before docs verification.

The observer materializes every registered template, using the shared synthetic provisioning fixture for the provision-required template, and checks the actual source/effective schemas and ordered grants. Separate structural and semantic guards check source ownership, prompt selection, policy, inventory order, native delta and presenter relationships. An emission or observer failure, timeout, or invalid output fails verification. Each independent observation has fresh output; the aggregate shares one observation across its tool claims. On settled success or failure the verifier removes only its exact allocated output directory, reporting cleanup failure without hiding the original failure. It neither requires the temporary parent to be empty nor controls incidental caches. Routine therefore emits disposable inventory output, not a distributable build.

Nineteen affected formerly default-budget Jest cases have explicit 15000 ms case timeouts for source emission/materialization; global/default and unrelated budgets are unchanged, as is the contract-values suite's 240000 ms budget. In prior qualification, “observes executable catalog changes” passed actual Jest; an independent hook measured 7343.086 ms, not a Jest timeout failure. A single-emission aggregate observation took 6.154 seconds and the heavy case took 129.449 seconds. These historical bounded measurements are not current full-suite certification or a product latency guarantee.

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 independently compiles each profile, checks its exact source and output closure and copies its selected artifacts. PAAD/newloop configuration equality includes ordered tools; no cross-profile prompt path or byte equality is required. 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%. The docs path starts healthy and rejects inventory and public-route drift; packaging starts healthy and rejects a missing selected prompt, checking exact sets/bytes/closure. Fixtures include the executable source and tooling closure, package and root tsconfig, and linked installed dependencies, not runtime state or working documents. Both tools use scripts/system-template-fixtures.js for synthetic provisioning. Distinct-driver and no-argv imports remain silent with invalid fixture inputs; importing the verifier alone does not allocate its output or launch compiler/observer children.

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

bash
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, then web:test:e2e:branding-smoke. The first owns production preview; the second owns a Vite dev server; the third exercises the real built Fastify /docs/ and web surfaces plus an isolated /saivage-v3/ Pages build. None targets a live deployment. Run npm run build first so the ordinary instance docs and web artifacts match source. Branding smoke builds its own Pages-prefixed docs under tmp/playwright-builds/branding-pages, without replacing ordinary docs output. It verifies all twelve SVG bytes/MIME, favicons, theme choices, gallery/download examples, desktop/360px layout and operator identity/navigation. Results/screenshots are under tmp/playwright-results/branding and are included in the existing CI browser failure-artifact upload. The browser-smoke CI job runs the complete three-suite profile after its matching build; brand assets, docs theme/config, landing and gallery edits select that job.

The ubuntu-24.04 hosted image supplies the APT configuration. The job uses npx playwright install-deps chromium to install host libraries without repository-authored APT source rewriting. The Ubuntu release label does not freeze image contents or guarantee network availability. Hosted browser qualification requires a successful dependency install and the complete browser-smoke job on the exact final commit, not installation alone.

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:

bash
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:

bash
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 pathApplicable expansion
docs or Markdown only outside other governed familiesRoutine/docs; Pages
src, bin, scripts, non-Playwright tests, Jest/TS configBackend build/Jest, backend E2E, lint
src/contracts or src/schemasBackend and UI/browser/lint
web or Playwright testsUI/browser/lint
Root/web manifest/lockBackend, UI/browser, dependency audit, lint
Workflow or unknown non-doc path; unavailable base/diffFail-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.

JobReal setup and check
routine-docs (always)Dual clean install, one validate:routine; included docs:verify is its sole docs gate
backend-jest-buildUbuntu24.04/x64; dual clean install, pinned Node/Python and isolated quality provisioning, build, canonical npm test, compiled native quality witnesses
backend-e2eRoot clean install, test:e2e; no web/browser/external service
ui-vitestDual clean install, web typecheck and complete Vitest
browser-smokeUbuntu24.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-hygieneDual clean install, audit:security
lint-guardsDual clean install, lint
docs-pages-build / docs-pages-deployAfter 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:

bash
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):

bash
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.

bash
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 ​

bash
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:

bash
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 &&):

bash
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:

bash
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.