dsh-vision-router 2.2.8 → 3.0.0

package/docs/architecture/3.0-architecture-plan.md

@@ -0,0 +1,252 @@
+# DVR 3.0 architecture plan
+
+Status: **complete through R10 post-main correctness closure**
+
+Baseline:
+
+- DVR `main@c61802dfc591410ba328b7f4c8f983b0e3d5f447`
+- DSH `deepseek-ai/deepseek-harness@639ed015397290b3745d163aafe02ffee4aa3f84` (`0.2.0-rc.2`)
+- 3.0 development branch: `3.0`
+- R9 architecture checkpoint: `1e331b1b8f8ea74a5cd38a1347f4e0bd13ef9ef9`
+- R9 architecture audit: `docs/architecture/3.0-r9-final-audit.md`
+- R10 post-main correctness implementation: `b38d427d54024f739dabbb3dacf389dc719a960f`
+- R10 closure: `docs/architecture/3.0-r10-final-correctness-closure.md`
+
+3.0 is **typed architecture consolidation**, not a repository-wide TypeScript rewrite.
+The success criterion is that changes to DSH contracts, lifecycle ownership, Settings,
+Session, provider contracts, and public package boundaries fail loudly at the nearest
+compiler/runtime/package gate. The percentage of files ending in `.ts` is not a goal.
+
+## Invariants inherited from 2.3
+
+3.0 must preserve the semantic owners established by 2.3:
+
+| Responsibility | Owner |
+| --- | --- |
+| routing/background authority | `lib/vision-routing-authority.js` |
+| routing evidence | `lib/vision-routing-evidence.js` |
+| planning/scoring | `lib/vision-capability-router.js` |
+| execution order | `lib/vision-execution-order.js` |
+| Session visual state/index | Session runtime/state/index owners |
+| managed artifacts | `lib/vision-artifact-store.js` |
+| DVR-owned provider HTTP | explicit `VisionProviderTransport` instance |
+| Host/product projection | server presentation boundaries |
+| browser rendering | client/presentation layer |
+
+High fan-out in `runtime-composition` is expected for a composition root and is not
+by itself an extraction target. Core extraction requires a stable semantic owner, not
+a line-count or import-count justification.
+
+## Required architecture direction
+
+```text
+DSH public contracts
+        |
+        v
+narrow Host boundaries
+        |
+        v
+DVR domain types
+        |
+        v
+Authority -> Evidence -> Planner -> Execution
+        |                       |
+        +------ composition ----+
+                  |
+                  v
+             mature core
+```
+
+Host types and DVR domain types must not become one giant interface graph.
+
+## Source/build target
+
+The target package model is:
+
+```text
+canonical source                    generated package artifact
+src/**/*.ts / transitional .js  -> lib/**/*.js
+client typed/transitional source -> lib/client.js
+                                  -> lib/types/**/*.d.ts
+```
+
+The preferred artifact directory remains `lib`; introducing `dist` has no identified
+architectural benefit. Ordinary generated Host JavaScript should not become a second
+checked-in source of truth.
+
+Host code remains unbundled ESM. Browser code is a separate build/type world.
+
+## Type ownership
+
+Use DSH package-exported public contracts wherever DSH owns the concept. DVR owns only
+DVR semantics such as routing decisions, capability evidence, image ownership, Session
+vision state, provider configuration, diagnostics, and resource ownership.
+
+Do not create a generic `DvrContext`, Host facade, service locator, DI container,
+global registry, or callback bag to make TypeScript conversion easier.
+
+## Runtime validation
+
+TypeScript never replaces validation at Settings/JSON, RPC, provider/network,
+filesystem, persisted state, environment, browser/Node, or user-input boundaries.
+
+Preferred rule:
+
+```text
+unknown -> boundary parser/official codec -> typed value -> domain
+```
+
+Schemastery remains the owner for plugin Config/Settings schema. Zod or another runtime
+validator is justified only for complex untrusted external shapes; browser code should
+not gain a heavyweight validator merely for type symmetry.
+
+## Host / Client programs
+
+Host and browser Client must be type-checked as separate programs. DSH itself separates
+the two because both sides augment Cordis Context under different runtime contracts.
+
+Host compilation should follow real Node ESM resolution rather than copying DSH's
+monorepo-only build choices mechanically. Current target for the Host compiler is
+NodeNext/NodeNext with explicit ESM extension discipline.
+
+## Browser constraint
+
+The existing `262144` byte single-file review bound for `lib/client.js` is frozen.
+3.0 must not raise it to make TypeScript fit. Client migration is an independent Go/No-Go
+workstream and may remain partly JavaScript if typed generation would weaken
+determinism, debugging, loader transparency, or the size gate.
+
+## Compatibility
+
+Runtime Host compatibility and durable user-data compatibility are independent.
+
+3.0 may raise the Host floor only after a dedicated evidence gate proves that the
+removed Host generations account for real compatibility complexity. A higher Host floor
+does not authorize deleting readers/migrations for persisted Settings, profile data,
+Session/replay data, attachment identity, or historical image ownership.
+
+No speculative DSH 0.3 implementation is part of this plan.
+
+## Production dependency policy
+
+Production runtime code may depend on documented/package-exported DSH faces. It must
+not import `@deepseek-ai/*/src/*` or DeepSeek Harness monorepo filesystem internals.
+
+Exact-source compatibility surveillance under `scripts/` and tests is a separate
+category: it may inspect upstream implementation source to detect Host drift or a shim's
+removal condition, but that source dependency must not enter runtime code, public
+declarations, or the npm runtime graph.
+
+## Public API direction
+
+R7 replaced the former transitive mature-Core export graph with an explicit package-root
+runtime/type surface. New Core exports no longer become package API automatically.
+
+`./client` remains a DSH loader entry and is not treated as an ordinary consumer
+library API.
+
+## Roadmap
+
+Final status:
+
+| Phase | Result |
+| --- | --- |
+| R0 | complete |
+| R1 | complete |
+| R2 | complete |
+| R3 | complete |
+| R4 | complete |
+| R5 | complete — production Browser TypeScript switch No-Go |
+| R6 | complete |
+| R7 | complete |
+| R8 | complete |
+| R9 | complete |
+| R10 | complete — post-main final correctness closure |
+
+R9 records the typed-architecture audit at its historical checkpoint. The post-main
+correctness findings and repairs are recorded separately in
+`docs/architecture/3.0-r10-final-correctness-closure.md`.
+
+### R0 - Baseline and contract ledger
+
+- freeze package/export/browser/support facts;
+- record DSH public type authorities;
+- classify current package-root exposure;
+- gate production private DSH source imports;
+- record compatibility candidates without deleting them.
+
+### R1 - Source/artifact boundary
+
+- establish `src` as canonical source and `lib` as generated output;
+- preserve behavior/module ownership during relocation;
+- add clean/reproducible artifact checks;
+- do not combine source moves with semantic refactors.
+
+### R2 - Type infrastructure and Host boundaries
+
+- separate Host and Client TypeScript programs;
+- add strict compiler policy;
+- type Settings, Session, LLM/provider, attachment, RemoteResult, and composition inputs
+  against DSH public contracts;
+- allow a controlled JS bridge during migration.
+
+### R3 - DVR domain types
+
+Type only stable DVR-owned semantics. Do not create interfaces without a named owner and
+a concrete coupling/risk they reduce.
+
+### R4 - Composition and mature Core
+
+Migrate composition/lifecycle before low-value algorithmic code. Mature Core conversion
+is incremental and must not trigger decomposition solely for file size.
+
+### R5 - Browser Client
+
+Run an independent typed-source/build experiment. Switch production ownership only when
+the output is deterministic, understandable, uses only supported runtime externals,
+passes real browser/Desktop tests, and stays at or below 256 KiB.
+
+### R6 - Compatibility retirement / Host floor
+
+Re-run every shim's documented removal condition. Host-floor changes are evidence-based
+and do not retire durable-data compatibility.
+
+### R7 - Public API
+
+Classify root exports as plugin contract, supported API, compatibility API, accidental
+internal, or test-only. Publish only deliberate types/runtime faces.
+
+### R8 - CI/release
+
+Add typecheck, lint, clean build, generated sync, reproducibility, packed declaration
+smoke, and source-to-artifact evidence without weakening the existing pack-once,
+tarball-identity, trusted-publishing, and provenance model.
+
+### R9 - Final audit
+
+Re-run ownership, lifecycle, dependency-cycle, browser, compatibility, package,
+Node 22/24, supported DSH, Desktop, adversarial, property, resource, and release audits.
+
+### R10 - Final correctness closure
+
+- review post-main implementation rather than treating R9 green evidence as transitive;
+- repair provider transport capture, dynamic Host validation and optional Cordis seams;
+- complete Session Vision sidecar/user-authority lifecycle ownership;
+- align package-root runtime and declaration contracts;
+- migrate CI trigger ownership from generated artifacts to canonical source;
+- verify the exact package candidate before tag creation while preserving pack-once.
+
+## Explicit non-goals
+
+- 100% TypeScript conversion;
+- Big Bang rewrite;
+- generic DI/service locator;
+- global current owner or registry;
+- `Object.create(core)` facade;
+- Config/Settings impersonation;
+- Core decomposition by LOC;
+- composition splitting by fan-out;
+- routing/Session/provider rewrites unrelated to a proven 3.0 seam;
+- browser size-limit increase;
+- importing DSH private implementation to obtain richer types;
+- deleting runtime validation because code is typed.

package/docs/architecture/3.0-r0-contract-ledger.md

@@ -0,0 +1,137 @@
+# DVR 3.0 R0 contract ledger
+
+Status: **R0 baseline**
+
+Audit baseline:
+
+- DVR source baseline: `main@c61802dfc591410ba328b7f4c8f983b0e3d5f447`
+- 3.0 planning commit: `9fe18fb0abe8732ee2848140e10113dfada92623`
+- DSH source baseline: `deepseek-ai/deepseek-harness@639ed015397290b3745d163aafe02ffee4aa3f84`
+- DSH package line at audit: `0.2.0-rc.2`
+
+R0 records facts and installs non-behavioral architecture gates. It does not move source,
+change Host support, delete compatibility, or alter plugin runtime behavior.
+
+## Package and runtime baseline
+
+| Contract | R0 value |
+| --- | --- |
+| package | `dsh-vision-router@2.3.0` |
+| module kind | ESM |
+| Node | `^22.19.0 || >=24.0.0` |
+| package root | `lib/public-entry.js` |
+| DSH browser entry | `lib/client.js` |
+| CLI | `lib/doctor-cli-p0.js` |
+| browser hard bound | `262144` bytes |
+| browser R0 size | `261672` bytes |
+| browser headroom | `472` bytes |
+| production ESM cycles at 2.3 close | 0 |
+
+The 256 KiB browser review bound is a retained constraint, not a migration target to relax.
+
+## Current root export topology
+
+The current root is intentionally **not** curated during R0:
+
+```text
+package "."
+  -> lib/public-entry.js
+     -> export * from ../entry.js
+        -> export * from ./index.js
+           -> export * from ./lib/vision-resilience.js
+```
+
+Static export inventory at the R0 baseline:
+
+- `index.js`: 101 direct named exports;
+- `lib/vision-resilience.js`: 13 named exports re-exported by `index.js`;
+- `entry.js`: 10 direct named exports plus the Core star export;
+- estimated distinct package-root named surface after shadowing/deduplication: **122 names**.
+
+This is an **inventory**, not an assertion that all 122 names are supported public API.
+R7 must classify every root export as one of:
+
+- `PLUGIN_CONTRACT`;
+- `PUBLIC_SUPPORTED`;
+- `PUBLIC_COMPAT`;
+- `INTERNAL_ACCIDENTAL`;
+- `TEST_ONLY`.
+
+R0 must not reduce this surface before that classification because doing so would mix API
+breakage with source/build migration.
+
+## DSH type authority ledger
+
+Production TypeScript must prefer package-exported DSH contracts where DSH owns the
+concept.
+
+| Concept | Current DSH authority |
+| --- | --- |
+| `RemoteResult` / remote failures | `@deepseek-ai/dsh-typert-protocol` |
+| Session client/controller faces | `@deepseek-ai/dsh-api-session-controller/client` |
+| Session/model-selection value contracts | `@deepseek-ai/dsh-api-session-controller/types` |
+| LLM/provider/message vocabulary | `@deepseek-ai/dsh-llm/types` |
+| attachment vocabulary | `@deepseek-ai/dsh-attachment` / exported types face |
+| Settings transport/view vocabulary | `@deepseek-ai/dsh-settings/types` |
+| generated client remote assembly | `@deepseek-ai/dsh-api-remotes/client` |
+| browser slots | `@deepseek-ai/dsh-client-ui-slots` |
+| ModelDirectory controller/state | `@deepseek-ai/dsh-client-ui-model-selection/client` |
+
+`ModelDirectory` and `ModelDirectoryState` are package-exported browser contracts, but
+remain model-selection UI/controller types. They are not DVR routing-domain types.
+
+## Production private-source policy
+
+R0 installs a hard architectural rule:
+
+> Production runtime code must not import or reference DSH package `src/*` entry points
+> or `deepseek-harness/packages/*/src/*` monorepo implementation paths.
+
+This applies to production entry points and `lib/**/*.js` now, and later to generated
+runtime output from `src`.
+
+The rule deliberately does **not** ban scripts/tests that inspect exact upstream source.
+Files such as `scripts/dsh017-source-contract.mjs` are upstream compatibility
+surveillance; they are allowed to inspect DSH implementation source because they do not
+enter the npm production runtime graph.
+
+## Compatibility baseline
+
+2.3 closes with runtime Host support spanning the 0.1.5 train and exact 0.2.0-rc.2
+evidence. 3.0 does not change that in R0.
+
+Runtime Host compatibility and durable-data compatibility remain independent. A later
+Host-floor raise cannot by itself remove replay, Settings/profile, Session, attachment,
+route-identity, or historical image-ownership readers.
+
+## R0 compatibility candidate: dsh-client-runtime
+
+Current DVR still names `@deepseek-ai/dsh-client-runtime` in two places:
+
+1. `package.json#dsh.client.inject`;
+2. `lib/doctor-runtime.js#HOST_PACKAGES`.
+
+At the audited DSH `0.2.0-rc.2` source baseline, repository search finds historical
+references but no current package implementation that establishes this as a current
+browser runtime package. DVR also has no identified `ctx.runtime` consumption.
+
+Classification: **candidate stale Host/browser edge, not yet deletion-authorized**.
+
+Removal requires real package/Host/browser evidence and must update both the manifest
+and Doctor assumption together. R0 records the candidate; R6 owns the decision.
+
+## R0 exit criteria
+
+R0 is complete when:
+
+- the 3.0 architecture plan exists in-repo;
+- this contract ledger exists;
+- the existing package/browser/support baselines remain unchanged;
+- CI runs on the 3.0 development branch;
+- production private DSH source references are forbidden by an executable architecture
+  test;
+- no runtime behavior, support floor, compatibility shim, release metadata, tag, npm
+  package, or GitHub Release is changed.
+
+The next phase is R1: establish a source/artifact boundary without mixing that move with
+semantic refactors.

package/docs/architecture/3.0-r1-source-artifact-boundary.md

@@ -0,0 +1,98 @@
+# DVR 3.0 R1 source/artifact boundary
+
+Status: **complete**
+
+R1 was intentionally split so source relocation and artifact removal were not performed
+in one unreviewable change.
+
+## Final source/artifact model
+
+The canonical editable runtime tree is `src/`, preserving the established 2.3 package
+artifact topology:
+
+```text
+src/entry.js / transitional .ts       -> entry.js
+src/index.js / transitional .ts       -> index.js
+src/lib/**/*.js / src/lib/**/*.ts     -> lib/**/*.js
+```
+
+`entry.js`, `index.js`, and `lib/**` are generated package artifacts and are no longer
+tracked by Git.
+
+The move did not authorize import rewrites, Core decomposition, public API contraction,
+or runtime ownership changes. Source relocation and TypeScript migration remain separate
+review dimensions.
+
+## Build ownership
+
+`scripts/build-source-artifacts.mjs` is the only writer for the package runtime tree.
+
+A normal `pnpm build`:
+
+1. removes any stale root `entry.js`, `index.js`, and `lib/**`;
+2. copies transitional canonical JavaScript from `src/` byte-for-byte;
+3. compiles canonical TypeScript in an isolated temporary output directory;
+4. copies compiled JavaScript into the established package artifact paths.
+
+This clean-before-build rule prevents deleted or renamed source modules from surviving as
+stale files that could later enter `pnpm pack`.
+
+`pnpm build:check` builds into a temporary directory and compares generated output with
+the current package tree without mutating it.
+
+`pnpm build:reproducible` performs two clean builds into independent temporary
+directories and compares relative paths, byte sizes, and SHA-256 hashes.
+
+## Install and package lifecycle
+
+Repository installs run `prepare -> pnpm build`, so workflows and direct test commands
+that historically consumed `lib/**` receive current artifacts from canonical source.
+
+The one security workflow that intentionally installs with `--ignore-scripts`
+(`adversarial-fuzz`) has an explicit build step.
+
+`prepack -> pnpm build` is an independent package safety gate. Packaging therefore does
+not rely on generated files being present in the checkout or left over from tests.
+
+Generated runtime paths are ignored by Git:
+
+- `/entry.js`;
+- `/index.js`;
+- `/lib/`.
+
+The npm `files` allowlist continues to name those artifact paths because they are package
+outputs, not repository source.
+
+## Workflow trigger migration
+
+Specialized workflows whose path filters referenced the old root `index.js`,
+`entry.js`, or `lib/**` now also follow `src/**`. This prevents removal of tracked
+artifacts from silently disabling architecture, Host, browser, resource, compatibility,
+or fuzz gates.
+
+## Browser client
+
+The browser client remains a separate workstream. Canonical browser source currently
+lives under `src/lib/client.js`; its deterministic embedded maintenance-actions sync is
+performed on canonical source before package artifacts are rebuilt.
+
+The existing 262144-byte hard review bound is unchanged.
+
+## R1 verification
+
+R1b was verified from a checkout with **zero tracked generated runtime artifacts**:
+
+- frozen install succeeded;
+- prepare rebuilt the runtime tree;
+- clean build succeeded;
+- generated artifact verification succeeded;
+- two-build reproducibility succeeded;
+- Host and Client typecheck succeeded;
+- full Node 22 and Node 24 test suites succeeded;
+- Linux and macOS native Host/sharp smoke succeeded;
+- Windows runtime regression succeeded;
+- Windows `pnpm pack` succeeded with generated artifacts ignored by Git;
+- the packed tarball installed into a DSH-like Host with the shared-sharp invariant intact.
+
+R1 is closed. Further source migration is R2/R3/R4 work and must preserve this build
+contract.

package/docs/architecture/3.0-r10-final-correctness-closure.md

@@ -0,0 +1,207 @@
+# DVR 3.0 R10 — Final Correctness Closure
+
+Status: **complete — integrated into `3.0` through PR #621**
+
+Implementation checkpoint:
+
+- implementation branch: `r10-final-correctness-closure`
+- original review base: `3.0@cc6bdd8d24bc186e13ae5bfa73502a30196aa16b`
+- implementation HEAD: `b38d427d54024f739dabbb3dacf389dc719a960f`
+- reconciled R10 head: `9c77880c69e3a85ff07666a83c9006d82cc48cba`
+- integration PR: `#621`
+- integrated `3.0` merge commit: `3e63545804617a3ffcd354cca05db9e6ff6918a5`
+- DSH authority: `deepseek-ai/deepseek-harness@639ed015397290b3745d163aafe02ffee4aa3f84` (`0.2.0-rc.2`)
+- package version: `2.3.0`
+- version bump / tag / npm publish: **not part of R10**
+
+R10 is a post-R9 correctness closure. It does not reopen the 3.0 architecture program,
+and it does not broaden the TypeScript migration. It reviews the implementation after
+current `main` was absorbed into `3.0`, then repairs concrete runtime, lifecycle,
+source-ownership, public-contract, and release-order defects found by code review.
+
+## Closure decisions
+
+### 1. Provider transport restores module-time Host fetch ownership
+
+The TypeScript migration had changed the module-time `globalThis.fetch.bind(globalThis)`
+snapshot into a wrapper that re-read `globalThis.fetch` on every request. That made the
+Router-owned direct-provider transport re-enter process-wide fetch wrappers installed
+later by Core/compat layers.
+
+R10 restores a real module-time bound fetch snapshot. The transport may still observe the
+live Undici global dispatcher as designed; it no longer observes later replacement of the
+`globalThis.fetch` function itself.
+
+### 2. Dynamic Host tool definitions keep runtime validation
+
+`vision-attachment-handle-runtime` again treats tool definitions as runtime Host input.
+Nullish or malformed registrations are passed through for Host-owned validation instead
+of throwing inside DVR merely because a TypeScript generic describes the expected shape.
+
+This preserves the 3.0 rule that static typing never replaces validation at dynamic Host
+boundaries.
+
+### 3. Optional Cordis capabilities use non-owning lookup semantics
+
+R10 removes remaining direct optional-service property fallbacks for:
+
+- `sessionQuery`;
+- `sessionProjections`;
+- `systemPrompt`;
+- `attachments`.
+
+These paths now use `Context#get` capability probes. Required services continue to be
+owned through the existing `inject`/composition seams. This prevents optional detection
+from accidentally becoming a Cordis pending dependency.
+
+### 4. Session Vision sidecar owns its complete async lifecycle
+
+The Session Vision policy domain now binds its consumer effect before asynchronous
+`storageDomain.open()` begins. Unload/HMR can therefore await and close an eventual late
+handle instead of leaving a same-name domain open in the longer-lived facility.
+
+The store also:
+
+- retires an old domain before opening against a replacement facility;
+- closes stale/late opens exactly once;
+- degrades to volatile authority after a storage failure without losing the current
+  in-process Session decision;
+- evicts durable hot-cache rows at Agent disposal while keeping durable Session truth for
+  future cold resume.
+
+Persistent policy retention remains Session-scoped by design; R10 does not add an
+arbitrary TTL that would break cold-resume semantics.
+
+### 5. User Session authority is connected to the official durable selection fact
+
+DSH rc.2 records explicit Session model changes as the durable `model/selection` event.
+R10 consumes that committed event and materializes DVR `source: 'user'` Session Vision
+policy from the exact selected route.
+
+This completes the authority model that already allowed user policy to outrank an
+inherited delegation snapshot. Delegation still creates a child-local snapshot and later
+parent changes do not retroactively mutate that child; a later explicit selection in the
+child Session can now override the inherited snapshot through a real production path.
+
+### 6. Package-root declarations match the package-root runtime
+
+`public-entry.d.ts` no longer exposes the internal third `runtime` argument of
+`src/entry.js` through package-root `apply()`. The package wrapper owns provider transport
+creation, so consumer injection of that internal seam is not public API.
+
+`installHostSettingsCompatibility` now declares and enforces both `namespace` and `Config`
+as required. The declaration source is included in the Host TypeScript program, and the
+packed consumer contract contains negative type assertions for both invalid calls.
+
+### 7. Provider transport teardown is an awaited Cordis disposer
+
+The public entry returns the transport-disposal Promise from its effect disposer instead
+of discarding it. HMR/plugin unload therefore waits for Router-owned dispatcher leases and
+ProxyAgent cleanup. The synchronous apply-failure path starts the same idempotent cleanup
+and absorbs cleanup rejection while rethrowing the original apply failure.
+
+### 8. CI triggers now follow canonical source ownership
+
+After R1, `src/**` is canonical and root `entry.js` / `index.js` / `lib/**` are generated
+package artifacts. R10 migrates workflow path filters and the CI impact classifier to the
+canonical source paths, including the real `.ts` extension for migrated owners.
+
+A repository contract now rejects workflow trigger ownership by generated package paths
+and verifies every literal canonical `src/**` trigger resolves to a real source file.
+
+### 9. Release correctness preserves both pre-tag verification and pack-once
+
+The release workflow no longer creates a new immutable tag before the exact package
+candidate is packed and inspected.
+
+The release sequence is now:
+
+```text
+verify exact main source
+  -> build / type / test / source-artifact gates
+  -> pin npm client
+  -> npm pack exactly once
+  -> verify packed public API
+  -> probe existing npm version against tarball SHA-1
+  -> persist exact tarball as same-run artifact
+  -> create/verify immutable tag
+  -> rehydrate the same tarball
+  -> verify SHA-1 + SHA-256 handoff
+  -> publish that exact tarball with trusted OIDC
+  -> registry identity wait + attestation + GitHub Release
+```
+
+This closes the tag-before-pack failure window without weakening the pre-existing
+pack-once / exact-tarball / provenance model.
+
+## Negative review
+
+R10 deliberately did **not**:
+
+- rewrite `src/index.js` or the mature Core; it remains byte-identical to current
+  `origin/main:index.js` at the implementation checkpoint;
+- introduce a generic `DvrContext`, Host facade, DI/service locator, global runtime owner,
+  or second source tree;
+- raise the browser `262144` byte gate; `src/lib/client.js` remains `261672` bytes;
+- convert the production browser client merely to increase TypeScript percentage;
+- add DSH private `/src/*` runtime imports;
+- change the advertised Host support window;
+- bump the package to `3.0.0`, create a tag, or publish a release.
+
+## Explicitly retained findings
+
+The following findings were intentionally kept outside R10 and remain visible for future
+work rather than being hidden by the closure:
+
+1. `runtime-composition.js` is still a JavaScript composition root. Its phase objects are
+   not compiler-enforced contracts. R10 does not convert it merely to satisfy a language
+   metric.
+2. `tsconfig.client.json` protects the browser-only compiler world, but production
+   `src/lib/client.js` is not under strict TypeScript/checkJs coverage. The R5 production
+   Browser TypeScript switch remains No-Go under the frozen size/build constraints.
+3. R9 remains historical evidence for `1e331b1`; R10 is the post-main correctness
+   checkpoint and does not rewrite R9 as though it had audited this later code.
+
+## Local implementation evidence
+
+At `b38d427d54024f739dabbb3dacf389dc719a960f` plus the documentation-only closure that
+follows it:
+
+```text
+canonical source files            182
+canonical runtime TS owners        38
+canonical public declarations       1
+canonical package artifacts       182
+browser client bytes           261672
+browser hard gate              262144
+```
+
+Source-to-artifact evidence digest:
+
+```text
+2a9f8d2c2ed1f60506871a0237383fd8e31304296360c1193009cfbf300a8821
+```
+
+Local post-fix validation completed with:
+
+- generated artifacts: `182/182` in sync;
+- Host + Client typecheck: pass;
+- source ownership lint: pass;
+- no remaining audited direct optional-service property reads;
+- main regression: `1605 tests / 1604 pass / 0 fail / 1 skip`;
+- backend runtime policy: `10/10` pass;
+- reproducible build: `182` artifacts verified;
+- targeted R10 transport/release/trigger regressions: pass;
+- workflow YAML parse: pass;
+- canonical workflow literal trigger audit: `0` invalid paths.
+
+These gates verify the repaired implementation; they are evidence after the code review,
+not a substitute for the code review that produced R10.
+
+## Exit decision
+
+R10 closes the concrete correctness defects found after R9 and after current `main` was
+absorbed into `3.0`. PR #621 has been reviewed for mergeability and integrated into `3.0`. The integrated
+branch is `0` commits behind current `main`; GitHub-side Host/Desktop/package evidence
+can now run against the integrated R10 head as part of the later 3.0 release-candidate
+phase. No further architecture migration pass is justified by R10 itself.