@kudzujs/core 0.8.62 → 0.9.1

package/docs/next-architecture/0.9-implementation-plan.md

@@ -0,0 +1,1819 @@
+# Kudzu 0.9.0 Detailed Implementation Plan
+
+## Document Role
+
+This document is the detailed delivery plan for [`0.9-semantic-compression.md`](./0.9-semantic-compression.md). The Semantic Compression document defines direction, work order, and release gates. This document decomposes that work into executable sessions, artifacts, tests, measurements, reviews, and stop conditions.
+
+This plan does not mark `0.9.0` as released. The current package version remains the version recorded in `package.json`. Package metadata, release notes, public support claims, and generator ranges change only during the final release procedure after every gate passes.
+
+Use this document to answer:
+
+```text
+What is the next exact task?
+What evidence authorizes it?
+Which producer and consumer boundary may change?
+Which files are expected to change?
+What must remain unchanged?
+Which positive and negative checks prove the boundary?
+Which measurements are required?
+When must work stop for architecture review?
+What evidence closes the task?
+```
+
+## Required Reading Order
+
+Every 0.9 implementation session reads these documents in order:
+
+1. [`MIGRATION_ROADMAP.md`](../../MIGRATION_ROADMAP.md)
+2. [`0.9-semantic-compression.md`](./0.9-semantic-compression.md)
+3. This implementation plan
+4. [`compiler-current-architecture.md`](./compiler-current-architecture.md)
+5. [`performance-gates.md`](./performance-gates.md)
+6. [`large-application-ai-native-roadmap.md`](./large-application-ai-native-roadmap.md)
+
+The first three documents define product authority, active work order, and execution detail. The remaining documents provide current implementation facts, measurement rules, completed foundation, and deferred work.
+
+## Release Thesis
+
+Kudzu `0.9.0` has two inseparable outcomes.
+
+### Semantic Outcome
+
+More realistic React-shaped applications reduce to the existing Semantic Kernel while compiler and browser complexity remain nearly flat.
+
+### Competitive Outcome
+
+For matched applications, Kudzu proves lower browser cost and equal-or-better user-facing performance than React + Vite and representative Vue, Svelte, Astro, and capability-appropriate production framework baselines.
+
+Internal architecture work without competitive proof cannot release as `0.9.0`. A favorable benchmark produced by omitted behavior, weaker accessibility, different content, different hosting assumptions, or unreported failures also cannot release as `0.9.0`.
+
+## Program Principles
+
+1. Performance is an invariant, not a cleanup phase.
+2. A real failing application fixture authorizes semantic work.
+3. Native browser behavior wins before compiler behavior is added.
+4. Existing semantics win before normalization is added.
+5. Normalization wins before an internal adapter is added.
+6. An internal adapter wins before a semantic primitive is considered.
+7. Three unrelated real fixtures permit architecture review but do not authorize a primitive.
+8. Package-specific source knowledge cannot reach generic IR consumers or browser runtime code.
+9. Browser JavaScript remains proportional to route capabilities.
+10. Static siblings remain complete HTML with zero JavaScript.
+11. Every unsupported neighboring form remains explicit and source-located.
+12. No benchmark result counts until behavior and accessibility checks pass.
+13. No task is complete without complexity and browser-byte accounting.
+14. No later work item starts while an earlier item is incomplete or lacks an explicit evidence-based closure.
+
+## Program Dependency Graph
+
+```text
+0.9.0-01 Baseline and benchmark restoration
+  |
+  +--> 0.9.0-02 Stronger Derived
+         |
+         +--> 0.9.0-03 Shared State and Actions
+                |
+                +--> 0.9.0-04 Resource Ownership Review
+                       |
+                       +--> 0.9.0-05 Component Ownership and Dependencies
+                              |
+                              +--> 0.9.0-06 Duplication Removal
+                                     |
+                                     +--> 0.9.0-07 Final Cross-Framework Proof
+                                            |
+                                            +--> 0.9.0 Release Candidate
+```
+
+Cross-framework harness restoration begins during 0.9.0-01 and runs continuously. The final proof occurs only after semantic and simplification work is complete.
+
+## Current Factual Baseline
+
+The following facts describe the current `0.8.62` tree. The completed dated architecture and complexity measurements are recorded in [`0.9-baseline.md`](./0.9-baseline.md).
+
+### Current Semantic Records
+
+| Record | Current authority | Known 0.9 pressure |
+|---|---|---|
+| `SymbolRef` | Source-local lexical identities | Preserve lexical identity outside AST-bearing analysis. |
+| `SignalIR` | Local and package-neutral state references | Preserve ownership and direct state semantics. |
+| `HandlerIR` | Commands, native handlers, effects, captures, imports, and actions | Equivalent source operations still enter through several syntax-specific paths. |
+| `BindingIR` | Reactive text, attributes, conditions, and evaluator exports | Derived identity is not authoritative for every binding calculation. |
+| `DerivedIR` | Tagged effect dependencies and keyed collection selectors | Reactive bindings and imported calculation fields use the same purity language but separate identity paths. |
+| `EffectIR` | Setup, cleanup, dependencies, subscriptions, owners, keyed membership, and Worker edges | Lifecycle proof is distributed across focused syntax passes. |
+| `SharedStateIR` | Reduced Zustand state identity and initial field value | Context action state does not currently lower through this record. |
+| `SharedActionIR` | Reduced Zustand action identity | Action implementation still retains adapter-specific transient metadata. |
+| `KeyedBlockIR` | Collection, selector, key, parent/child, row hooks, and ownership | Keep current identity and release semantics. |
+| `ImportIR` | Validated source/package import references used by browser modules | Keep import ownership structural and route-specific. |
+| ComponentAnalysis v2 | Owners, specializations, states, props, refs, IDs, and signal links | Several source-shape discovery loops surround one specialization core. |
+| RouteIR v1 | Concrete route state, event, effect, binding, condition, list, and ownership plan | Preserve complete HTML and concrete ownership. |
+| CapabilityIR v1 | Exact runtime capability projection | Preserve zero-cost exclusion and runtime-family isolation. |
+
+### Current Ordered Normalization Inventory
+
+The page compilation path contains fifteen ordered entries. Imported declaration normalization omits the conditional imported-static-collection entry and therefore contains fourteen. The dated baseline verifies this against `normalizeCompilerSource()`.
+
+| Order | Entry | Owner | Canonical result |
+|---|---|---|---|
+| 1 | Imported static collections | `source-compiler.mjs` | Build-known array literals |
+| 2 | React Router | `router-pass.mjs` | Native navigation and route signals |
+| 3 | `clsx` | `source-compiler.mjs` | Primitive conditional concatenation |
+| 4 | Static media query store | `browser-signal-passes.mjs` | Ordinary state plus owned effect |
+| 5 | React migration syntax | `react-migration-pass.mjs` | Supported React source normalized for later no-React compilation validation |
+| 6 | Navigator capability condition | `browser-signal-passes.mjs` | False state plus mount effect |
+| 7 | Parameterized debounce hook | `source-compiler.mjs` | Ordinary state plus dependency effect |
+| 8 | Outside-click hook | `outside-click-pass.mjs` | Canonical callback value/dependencies for an authored owned listener effect |
+| 9 | Effect-private refs | `effect-private-ref-pass.mjs` | Invocation-private effect closure values |
+| 10 | Custom-hook timer refs | `custom-hook-timer-pass.mjs` | Hidden state plus existing effect ownership |
+| 11 | `useId` validation | `react-migration-pass.mjs` | Diagnostic-only boundary |
+| 12 | Lazy state/reducer initializers | `source-compiler.mjs` | Direct serializable initial literals |
+| 13 | Zustand | `zustand-pass.mjs` | Package-neutral shared-state creation marker |
+| 14 | Render control flow | `render-control-pass.mjs` | Canonical conditions and immutable assignments |
+| 15 | Worker ordinary-import validation | `worker-compiler.mjs` | Diagnostic-only boundary |
+
+The baseline records structural transforms and diagnostic-only entries separately. Pass count must not be reduced by relabeling a pass or moving identical work into `source-compiler.mjs`.
+
+### Current Test And Benchmark Entry Points
+
+| Command | Current role |
+|---|---|
+| `npm run check` | TypeScript checks plus production build of the repository site |
+| `npm test` | 233 current Node tests; Chrome work is optional unless explicitly required |
+| `KUDZU_REQUIRE_CHROME=1 CHROME_BIN="..." npm test` | Required browser journey execution |
+| `npm run test:package` | Packed-package installation and smoke validation |
+| `npm run benchmark` | Seven clean Worker/effect fixture builds and artifact sizes |
+| `RUNS=7 CHROME_BIN="..." npm run benchmark:keyed` | 2,000-row keyed build/browser ownership benchmark |
+| `npm run benchmark:source-scale` | Generated source graph compile/build/RSS benchmark |
+| `npm run benchmark:commerce` | Paired Kudzu revision benchmark against `kudzu-based-bench` |
+| `npm run benchmark:module-cache` | Historical 100-importer cache seam benchmark |
+| `npm run benchmark:native` | Historical native-handler ownership comparison |
+
+### Current Evidence Strengths
+
+- Static routes and static siblings repeatedly prove zero JavaScript.
+- Effect dependency replacement, cleanup order, and stale setter invalidation are covered.
+- Worker navigation and repeated mount/dispose ownership have strong browser coverage.
+- Context CRUD and Zustand layout persistence have browser journeys.
+- Component callback/ref propagation, repeated state, and conditional remount are covered.
+- Keyed identity, SVG ownership, nested lists, and row release are extensively covered.
+- Source-scale and 1,000-product build measurements exist.
+
+### Current Evidence Gaps
+
+- No authorizing real fixture proves one reusable multi-state `DerivedIR` identity across binding, effect, and list consumers.
+- Context does not currently prove the same package-neutral shared-state/action records as Zustand.
+- No current resource fixture exceeds existing `EffectIR` plus effect-private closure semantics.
+- WorkLedger revision `3d8bf2130ec1d7698bff07fb00726b2bb94d20d4` now proves general immutable object-property propagation through an ordinary component boundary fails at a selected effect dependency shared with a keyed-list consumer.
+- No maintained 100/1,000/10,000-route cross-framework gate is recorded in this repository.
+- The documented runtime matrix is not currently reproducible from a tracked harness in this checkout.
+- The six-route commerce browser comparison timed out before cross-target sampling.
+- Browser CPU, heap, disabled-JS, delayed-JS, and missing-chunk release gates are not maintained in this checkout.
+- Astro is absent from the maintained stateful runtime matrix; Vue and Svelte are absent from the production commerce matrix.
+
+## Measurement Taxonomy
+
+All 0.9 reports use the same categories so one improvement cannot hide a loss elsewhere.
+
+### Compiler Complexity
+
+| Metric | Meaning |
+|---|---|
+| Semantic concepts | Conceptual kernel additions, not merely type names |
+| ModuleIR record kinds | New serialized semantic contracts |
+| Core semantic passes | Analysis stages that introduce or transform semantic meaning |
+| Ordered normalization entries | Source transforms and validators invoked by the pipeline |
+| Core compiler LOC | Maintained semantic analysis and IR file set |
+| Compatibility LOC | React, Router, Zustand, and migration-specific normalizers/adapters |
+| Runtime concepts | Browser-level state, scheduler, graph, registry, or lifecycle machinery |
+| Diagnostics | Added stable boundary messages and negative forms |
+
+### Browser Cost
+
+| Metric | Required view |
+|---|---|
+| Initial JavaScript | Raw, gzip, and actual browser-transferred bytes |
+| Route JavaScript | Capability and handler/effect graph by route |
+| Session JavaScript | Unique bytes fetched across the complete journey |
+| Parse/execute CPU | Browser trace or equivalent reproducible measurement |
+| Heap | Initial, post-journey, and after repeated navigation/disposal |
+| Interaction readiness | Content visible to action safely accepted |
+| Event latency | Event to next paint or verified DOM completion |
+| Navigation latency | Trigger to destination content/action readiness |
+| Failure resilience | Disabled, delayed, and missing JavaScript behavior |
+
+### Build Cost
+
+| Metric | Required view |
+|---|---|
+| Cold build | Fresh output and scratch removal |
+| Warm/replacement build | Existing output where supported |
+| Incremental development build | Changed module to ready output |
+| Source read | Filesystem/source indexing phase |
+| Graph | Reachability and symbol graph phase |
+| Compile | Semantic source compilation phase |
+| Render/emission | Route rendering, bundling, and output phase where available |
+| Peak RSS | Fresh-process maximum resident set |
+| Output | Files, pages, bytes, hashes, and artifact classes |
+
+## Baseline File Sets
+
+0.9.0-01 records LOC for stable, explicit file sets. Changing a category requires updating both baseline and candidate calculations and explaining the reason.
+
+### Core Semantic Compiler
+
+```text
+framework/compiler/source-compiler.mjs
+framework/compiler/descriptor-session.mjs
+framework/compiler/handler-lowering.mjs
+framework/compiler/effect-analysis.mjs
+framework/compiler/collection-analysis.mjs
+framework/compiler/normalization-pipeline.mjs
+framework/compiler/analysis/binding-index.mjs
+framework/compiler/analysis/component-analysis.mjs
+framework/compiler/ir/module-ir.mjs
+```
+
+### Compatibility And Focused Normalization
+
+```text
+framework/compiler/react-migration-pass.mjs
+framework/compiler/router-pass.mjs
+framework/compiler/zustand-pass.mjs
+framework/compiler/browser-signal-passes.mjs
+framework/compiler/effect-private-ref-pass.mjs
+framework/compiler/custom-hook-timer-pass.mjs
+framework/compiler/outside-click-pass.mjs
+framework/compiler/render-control-pass.mjs
+```
+
+### Semantic Code Generation And Browser Evaluation
+
+```text
+framework/compiler/handler-codegen.mjs
+framework/compiler/effect-codegen.mjs
+framework/compiler/list-runtime-codegen.mjs
+framework/compiler/runtime-codegen.mjs
+framework/compiler/codegen/command-codegen.mjs
+framework/collection-selector.js
+framework/effect-runtime.js
+framework/native-runtime.js
+framework/list-runtime.js
+framework/shared-runtime.js
+```
+
+Use tracked source only. Blank lines and comments remain included because the purpose is reproducible trend accounting, not language-normalized complexity theory.
+
+Example command shape:
+
+```bash
+wc -l <explicit-file-list>
+```
+
+The completed baseline must record the expanded command rather than relying on shell history.
+
+## Work Item 0.9.0-01: Freeze And Restore The Baseline
+
+### Objective
+
+Create the reproducible architectural, correctness, output, build, browser, and cross-framework baseline against which every 0.9 change is judged.
+
+### Prohibited Work
+
+- No semantic support expansion.
+- No production compiler optimization.
+- No runtime change.
+- No fixture rewrite intended to make Kudzu look better.
+- No package version or release-note change.
+- No benchmark claim based on historical versions presented as current.
+
+### Session 01A: Architecture And Complexity Ledger
+
+**Inputs:** current tree, current architecture document, current ModuleIR validator, normalization pipeline.
+
+**Tasks:**
+
+1. Verify the current package version and exact Git revision.
+2. Verify the fifteen-entry normalization order from code.
+3. Classify every entry as transform, validator, adapter, or mixed proof/transform.
+4. Map each entry to Semantic Kernel concepts produced or validated.
+5. Record every ModuleIR record kind and structural reference.
+6. Record every browser runtime concept and emitted module family.
+7. Run the explicit LOC commands for the three baseline file sets.
+8. Record `source-compiler.mjs` separately because it is the principal residual coupling point.
+9. Record current test count and Chrome-required test count.
+10. Add a dated baseline ledger to `0.9-semantic-compression.md` or a linked results document.
+
+**Expected files:** documentation only.
+
+**Done evidence:** exact commands, exact revision, counts, file sets, and no production diff.
+
+### Session 01B: Output And Capability Baseline
+
+**Tasks:**
+
+1. Run `npm run check` from a clean output state.
+2. Record emitted page count and interactive/static route count.
+3. Record representative static, command, binding, list, effect, Worker, runtime-parameter, navigation, and package-effect routes.
+4. Record complete emitted file lists for representative fixtures.
+5. Record raw/gzip bytes by runtime, handler, effect, Worker, CSS, and HTML class.
+6. Verify React, React Router, and supported erased package references do not survive where forbidden.
+7. Verify static siblings contain no module scripts, state markers, or indirect capability preload.
+8. Record deterministic hashes for maintained representative output.
+
+**Stop condition:** any nondeterministic output must be investigated before performance sampling.
+
+### Session 01C: Correctness And Browser Baseline
+
+**Tasks:**
+
+1. Run `npm test` and record all tests.
+2. Run `KUDZU_REQUIRE_CHROME=1 CHROME_BIN="..." npm test` and record browser version.
+3. Run `npm run test:package`.
+4. Record currently exercised browser journeys by semantic category.
+5. Record disabled-JS, delayed-JS, missing-chunk, slow-network, and slow-CPU gaps explicitly.
+6. Record unresolved terminal/WebSocket browser coverage gaps.
+7. Record the existing commerce navigation timeout as a failure, not an omitted result.
+
+**Done evidence:** all available checks pass or each existing failure has an owner and blocker entry.
+
+### Session 01D: Kudzu-Only Performance Baseline
+
+**Tasks:**
+
+1. Run `npm run benchmark`.
+2. Run the keyed benchmark with at least seven fresh Chrome profiles.
+3. Run source-scale at the maintained default.
+4. Run source-scale at 100 routes.
+5. Attempt source-scale at 1,000 routes.
+6. Attempt source-scale at 10,000 routes only after estimating disk/time requirements from the lower scales.
+7. Record unavailable or impractical sizes honestly rather than reducing semantic content silently.
+8. Record fresh-process peak RSS, raw arrays, medians, min/max, output digest, and environment.
+
+**Commands:**
+
+```bash
+npm run benchmark
+RUNS=7 CHROME_BIN="/path/to/chrome" npm run benchmark:keyed
+ROUTES=100 WARMUPS=1 RUNS=7 npm run benchmark:source-scale
+ROUTES=1000 WARMUPS=1 RUNS=7 npm run benchmark:source-scale
+ROUTES=10000 WARMUPS=1 RUNS=7 npm run benchmark:source-scale
+```
+
+The generated source-scale fixture is a compiler diagnostic. It cannot replace matched cross-framework application scaling.
+
+### Session 01E: Restore The Maintained Cross-Framework Harness
+
+**Objective:** make current comparison claims reproducible from a pinned public benchmark revision and tracked Kudzu instructions.
+
+**Current external reference:** `SimYunSup/kudzu-based-bench` revision `f2d5be1a516c539e30f7125f6870d42b1dd02ecd` is the historical pinned baseline. A new revision may replace it only after review of fixture parity and lockfile changes.
+
+**Tasks:**
+
+1. Clone and detach the pinned external revision.
+2. Verify comparator package versions from the lockfile.
+3. Run the existing commerce build and artifact commands without modification.
+4. Reproduce the existing 1,000-product Kudzu result.
+5. Reproduce or characterize the commerce browser timeout.
+6. Decide whether the harness remains external or a tracked minimal orchestrator belongs in Kudzu.
+7. Do not duplicate the benchmark applications into the compiler repository unless reproducibility cannot otherwise be guaranteed.
+8. Ensure Kudzu documentation points to a real command and tracked or public immutable input.
+9. Pin browser, Node, package manager, OS/hardware, CPU throttle, network profile, and cache policy.
+10. Record all comparator failures.
+
+**Historical reproduction shape:**
+
+```bash
+git clone https://github.com/SimYunSup/kudzu-based-bench.git /tmp/kudzu-based-bench
+git -C /tmp/kudzu-based-bench checkout --detach f2d5be1a516c539e30f7125f6870d42b1dd02ecd
+pnpm --dir /tmp/kudzu-based-bench install --force
+pnpm --dir /tmp/kudzu-based-bench run build:commerce
+```
+
+**Available external scenarios to verify:**
+
+```bash
+pnpm --dir /tmp/kudzu-based-bench run build:shop
+pnpm --dir /tmp/kudzu-based-bench shop:scale -- --sizes 100,1000,10000 --runs 3
+pnpm --dir /tmp/kudzu-based-bench shop:assets
+pnpm --dir /tmp/kudzu-based-bench shop:bench -- --variant shop-kudzu --runs 7 --cpu 4 --net slow4g
+pnpm --dir /tmp/kudzu-based-bench shop:report
+```
+
+Three sequential scale samples are insufficient for the final Kudzu gate. The accepted harness must use rotating/interleaved target order, one warm-up, at least seven samples, and more samples when ranges overlap.
+
+### Session 01F: Cross-Framework Contract
+
+Create one checked contract for every compared scenario.
+
+| Contract field | Required content |
+|---|---|
+| Scenario ID | Stable readable name |
+| Application class | Content or stateful interactive |
+| Routes | Exact route set and emitted page count |
+| Data | Same deterministic input and generation seed |
+| Behavior | User-visible action and expected result list |
+| Accessibility | Roles, names, keyboard behavior, focus, status, and errors |
+| Progressive enhancement | Disabled, delayed, and missing-JS expectation |
+| Hosting | Static server, compression, cache, and navigation assumptions |
+| Browser | Exact version and launch flags |
+| Framework | Exact package and lockfile versions |
+| Success gate | Automated behavior checks that run before timing |
+| Measurements | Bytes, readiness, events, navigation, CPU, heap, resilience, build |
+
+**Anti-gaming rule:** framework variants may use idiomatic production configuration, but may not remove required behavior, accessibility, data, routes, or error handling.
+
+### Session 01G: Baseline Sign-Off
+
+0.9.0-01 completes only when:
+
+- architecture and LOC ledgers are dated and reproducible;
+- output manifests and capability bytes are recorded;
+- Node and required Chrome tests pass;
+- package smoke passes;
+- Kudzu-only performance baselines are recorded;
+- the external benchmark revision and comparator versions are pinned;
+- known harness gaps and failures are explicit;
+- no production source or deploy output changed solely to establish the baseline.
+
+## Work Item 0.9.0-02: Strengthen Derived
+
+### Objective
+
+Make realistic pure multi-state calculations first-class semantic values whose dependencies and selected outputs can feed direct bindings, effects, and keyed collections without syntax-specific browser behavior.
+
+### Authorization Gate
+
+Work cannot start until:
+
+- 0.9.0-01 is complete;
+- a real upstream application or public benchmark scenario is pinned;
+- the first unsupported source location is reproduced with current Kudzu;
+- the reduced fixture retains the upstream semantic shape;
+- the reduction cannot be solved by native behavior or existing source restructuring that would remain ordinary React authoring.
+
+### Candidate Fixture Classes
+
+These are investigation candidates, not authorization by themselves:
+
+| Candidate | Required semantic pressure |
+|---|---|
+| Commerce variant selection | Color, size, and static variants derive price, stock, image, and availability |
+| Financial projection | Multiple inputs derive totals, status fields, and a chart collection |
+| Filtered availability | Search, category, inventory, and static catalog derive summary plus keyed results |
+
+The first fixture must record upstream URL, commit, license, acquisition hash, original source, and reduced source. The second unrelated fixture must prove the same semantic representation before 0.9 closes.
+
+### Target Semantic Contract
+
+```text
+Derived
+  identity: stable source-local slot
+  dependencies:
+    direct SignalIR references
+    serializable static captures
+  computation:
+    existing tagged pure expression/selector vocabulary
+  result:
+    deterministic JSON-safe primitive, object, or array
+  consumers:
+    selected BindingIR field
+    selected EffectIR dependency
+    selected KeyedBlockIR collection
+```
+
+The target contract does not require a new public API or browser graph. It should reuse `collection-analysis.mjs` and `collection-selector.js` unless a fixture proves those contracts insufficient.
+
+### Current Producer/Consumer Seam
+
+| Concern | Current owner | Required convergence |
+|---|---|---|
+| Pure expression parsing | `collection-analysis.mjs` | Remain canonical |
+| Derived registration | `descriptor-session.mjs` | Own explicit state/static dependencies |
+| Effect dependency | `effect-analysis.mjs` | Reference selected derived semantics |
+| Keyed selector | `source-compiler.mjs` | Continue using existing selector records |
+| Reactive binding | `source-compiler.mjs` | Stop bypassing semantic identity where fixture requires reuse |
+| Imported calculation | `source-compiler.mjs` | Reuse the same deterministic result contract |
+| IR validation | `module-ir.mjs` | Validate every selected consumer edge |
+| Browser evaluation | `collection-selector.js` | Remain the only general tagged evaluator |
+
+### Session 02A: Fixture Intake And Failure Census
+
+1. Pin the real fixture source.
+2. Build it unchanged where feasible.
+3. Record every unsupported site but select only the first Derived blocker.
+4. Reduce the blocker without changing state dependencies or result behavior.
+5. Add one static sibling.
+6. Add one build test that fails before compiler changes.
+7. Add no semantic implementation in this session.
+
+**Result:** complete on 2026-08-18.
+
+- Authorizing source: Medusa's MIT-licensed `ProductActions` at revision `9818886f06e493cb2249733d114d339aa216ef00`.
+- Evidence and hashes: [`test/fixtures/derived-medusa-product-actions/README.md`](../../test/fixtures/derived-medusa-product-actions/README.md).
+- Reduced fixture: [`test/fixtures/derived-medusa-product-actions`](../../test/fixtures/derived-medusa-product-actions).
+- Preserved pressure: two selected option values, immutable variants, deterministic selected object, selected price/availability bindings, and a selected-ID effect dependency.
+- First unsupported site: `src/pages/index.tsx:11:7`, where `[selected.id]` reports `useEffect() dependencies must be direct state or runtime parameter identifiers or property reads`.
+- Failure census: the reduced fixture has one observed Derived blocker. Removing only the effect makes both routes build, proving the imported calculation and selected binding fields are already supported. The unreduced Next.js application has unrelated framework/package boundaries and is not used to authorize them.
+- Static sibling: `src/pages/static.tsx`; it remains non-interactive, though the current red build stops before deploy emission.
+- Semantic implementation: none.
+- Accounting: zero semantic primitives, ModuleIR kinds, core passes, core/compatibility LOC, runtime concepts, and browser bytes added; one fixture and one expected-red focused test added; no benchmark delta exists because production source is unchanged.
+- Verification: `npm run check` passes; the full suite reports 233 pass and the one authorizing test failure out of 234 tests.
+
+Session 02B input:
+
+```text
+Authorizing fixture: Medusa ProductActions reduction
+First unsupported source location: src/pages/index.tsx:11:7, selected.id effect dependency
+Canonical semantic reduction: pending 02B; prefer one existing tagged Derived identity with explicit color/size signal dependencies and static variant capture
+Existing IR producer: imported calculation and binding analysis in source-compiler.mjs
+Existing IR consumers: BindingIR succeeds; EffectIR does not accept the selected calculation field
+Owner and release boundary: page-owned dependency effect with existing invalidation and cleanup rules
+Nearby rejected forms: whole-result dependencies, dynamic fields, mutation, cycles, opaque captures, and nondeterministic results
+Expected browser capability delta: none; reuse the existing effect and tagged evaluator capabilities
+```
+
+### Session 02B: Semantic Reduction Design
+
+Complete the per-slice contract:
+
+```text
+Authorizing fixture:
+First unsupported source location:
+Canonical semantic reduction:
+Existing IR producer:
+Existing IR consumers:
+Owner and release boundary:
+Nearby rejected forms:
+Expected browser capability delta:
+```
+
+Review questions:
+
+1. Can the fixture use an existing tagged expression?
+2. Are all state dependencies explicit by lexical identity?
+3. Are static captures JSON-safe and immutable?
+4. Is the result deterministic on every path?
+5. Can every consumer select a static property?
+6. Can existing route state subscriptions schedule evaluation?
+7. Can `Object.is` suppress unchanged selected effect values?
+8. Does list evaluation preserve retained keyed identity?
+9. Does the design change three unrelated core subsystems?
+
+If question 9 is yes, stop for architecture review before implementation.
+
+### Session 02C: Minimal Producer Slice
+
+Expected files are limited to the authorizing fixture, focused compiler test, and the smallest producer boundary among:
+
+```text
+framework/compiler/collection-analysis.mjs
+framework/compiler/descriptor-session.mjs
+framework/compiler/source-compiler.mjs
+framework/compiler/ir/module-ir.mjs
+```
+
+Required checks:
+
+- deterministic JSON round-trip;
+- stable signal dependency order;
+- no AST in finalized IR;
+- no arbitrary call support;
+- no browser-byte change before a consumer uses the result;
+- malformed references fail before codegen.
+
+### Session 02D: Binding Consumer
+
+Add the smallest direct text/attribute consumer required by the fixture.
+
+Required behavior:
+
+- build-known initial result appears in complete HTML;
+- only source states are subscribed;
+- direct known DOM targets update;
+- component functions do not execute in the browser;
+- no second expression evaluator is emitted;
+- an unrelated static sibling remains zero JavaScript.
+
+### Session 02E: Selected Effect Dependency
+
+Add only if the authorizing fixture requires it.
+
+Required behavior:
+
+- dependency scheduling follows source state commits;
+- selected field evaluation happens through existing semantics;
+- `Object.is` prevents rerun when the selected field is unchanged;
+- cleanup runs before replacement setup;
+- invalidation prevents stale writes;
+- whole-result and dynamic-field dependencies remain rejected unless independently justified.
+
+**Sessions 02B-02E result:** complete on 2026-08-18.
+
+- Semantic reduction: one calculation `DerivedIR` owns explicit `color` and `size` `SignalIR` dependencies, one existing generated `BindingIR` evaluator, and static result fields `id`, `price`, and `available`.
+- Binding consumers: price text and availability attribute `BindingIR` records reference the same calculation identity and retain their existing direct DOM evaluators.
+- Effect consumer: `EffectIR` selects static field `id`, subscribes only to the two source signals, and evaluates through the generated handler module before unchanged `Object.is` comparison.
+- Browser behavior: initial `black-m`, same-value suppression, `ivory-m`, and `ivory-s` price/availability transitions pass in required Chrome.
+- Static exclusion: `/static` emits complete HTML and zero JavaScript; no `kudzu-collection-selector.js` or calculation-specific runtime is emitted.
+- ModuleIR: no new record kind; the existing tagged `DerivedIR`, `BindingIR`, and `EffectIR` records gain validated calculation/evaluator/field edges.
+- Production delta: 151 added and 24 removed lines across the existing producer, IR validation, RouteIR projection, effect codegen, build projection, and core route-render boundary. Core semantic file-set delta is +101 net lines. No normalization entry or compiler pass was added.
+- Fixture JavaScript: 14,098 raw / 6,242 gzip bytes across seven existing capability artifact classes; the effect entry is 2,411 raw / 1,043 gzip bytes and the shared handler module is 816 raw / 344 gzip bytes.
+- Verification: `npm run check`, 234/234 Node tests, 234/234 required-Chrome tests, focused ModuleIR malformed-edge checks, and local Markdown links pass.
+
+Session 02F is skipped for this fixture because the calculation has no array field. This does not close the keyed-collection consumer generally.
+
+### Session 02F: Keyed Collection Consumer
+
+Add only if the same semantic result includes a required array field.
+
+Required behavior:
+
+- retained keys preserve DOM, state, effect, and ref identity;
+- removed keys release ownership exactly once;
+- re-added keys receive fresh state;
+- latest item data reaches handlers;
+- SVG namespace remains correct where applicable;
+- non-array result at runtime fails safely and explicitly.
+
+### Session 02G: Negative Boundary
+
+Required negative fixtures:
+
+- dynamic result property;
+- mutation;
+- cyclic derived locals;
+- nondeterministic call;
+- opaque or nonserializable capture;
+- package import in generic derived computation;
+- fallthrough or inconsistent result shape;
+- async helper;
+- dynamic dependency discovery;
+- unsupported whole-object effect dependency.
+
+Diagnostics must identify the authored source, semantic reason, supported forms, and safe migration direction.
+
+**Result:** complete on 2026-08-18.
+
+- One focused source-index test covers computed fields, whole-result dependencies, composed arguments, mutation, local cycles, nondeterministic calls, opaque relative captures, package imports, inconsistent fields, fallthrough, and async helpers.
+- Validation runs only for imported calculation fields selected by an effect. Existing reactive imported calculations that do not enter this boundary retain their prior behavior and diagnostics.
+- Every failure reports the authored page or helper source. No generated path, fallback evaluator, runtime, normalization pass, or adapter was added.
+
+### Session 02H: Second Unrelated Fixture
+
+The second fixture must use the same representation without adding another semantic record or evaluator. If it requires a second syntax-specific implementation, the first abstraction is not yet proven.
+
+**Result:** complete on 2026-08-18.
+
+- Second source: Mercury Agent's MIT-licensed Profit Sharing page at revision `829b1713740c5d551155540df712de9243c9e415`.
+- Evidence and hashes: [`test/fixtures/derived-mercury-profit-sharing/README.md`](../../test/fixtures/derived-mercury-profit-sharing/README.md).
+- Preserved pressure: four primitive financial inputs derive cumulative scalar summaries and an adjustable keyed yearly projection.
+- The fixture reuses the Medusa calculation `DerivedIR`, generated binding evaluator, source-signal ordering, scalar `BindingIR`, selected `EffectIR`, and calculated keyed-list path without production compiler changes.
+- Chrome proves scalar updates, retained year-one/year-two DOM identity, year-three insertion/removal, fresh year-three re-entry, and static-sibling zero-JavaScript output.
+- Session 02F therefore closes through Mercury's direct `rows` field. Existing keyed ownership supplies reconciliation and release; no selector runtime or calculation-specific list runtime is emitted.
+
+### Session 02I: Derived Closure Report
+
+Report:
+
+```text
+Semantic primitives added:
+Core passes added/removed:
+Core compiler LOC delta:
+Runtime concepts added:
+Browser raw/gzip delta by fixture:
+Normalization rules added/removed:
+Fixtures added:
+Build delta:
+Event/effect/list delta:
+```
+
+Expected result: zero semantic primitives, zero runtime concepts, one existing evaluator, and no JavaScript on build-folded/static siblings.
+
+**Result:** complete on 2026-08-18.
+
+```text
+Semantic primitives added:       0
+ModuleIR record kinds added:     0
+Core passes added/removed:       0 / 0
+Core compiler LOC delta:         +180 (4,961 -> 5,141)
+Production source net delta:     +206 lines
+Runtime concepts added:          0
+Normalization rules added:       0
+Adapter rules added:             0
+Positive fixtures added:         2
+Negative boundary forms added:   10 in one focused corpus test
+```
+
+Browser and output accounting:
+
+| Fixture | Interactive JS raw/gzip | Static sibling JS | Calculation/selector runtime |
+|---|---:|---:|---|
+| Medusa Product Actions | 14,098 / 6,242 B | 0 B | None |
+| Mercury Profit Sharing | 30,698 / 11,439 B | 0 B | Existing keyed-list runtime only |
+
+- Medusa deploy digest: `147a2bffd2085a540799aabb92655362607d170f251d4d41272d20cde7911fa3`.
+- Mercury deploy digest: `24e100996f23068634d4ebab72c5f8a9c39e8f7b6d4c05c10dee3fcdca032daf`.
+- Both fixture graphs omit `kudzu-collection-selector.js`; static siblings contain no script or state marker.
+- The maintained Worker/effect benchmark remains 907 raw / 477 gzip B for the Worker graph and 13,786 raw / 5,931 gzip B for the window graph. Its seven-run build median is 169.7 ms versus the 177.4 ms baseline, a non-material directional change of approximately -4.3% with identical artifact bytes.
+- Final verification passes on Node 24.14.0 and Google Chrome 151.0.7922.138: `npm run check` builds 174 pages with 2 interactive pages, the required-Chrome suite passes 236/236 tests, and `npm run test:package` installs 4 packages and builds 1 static page with 0 interactive pages.
+- The core LOC increase is explicit debt for Work Item 0.9.0-06. Final release still requires core LOC to return to baseline or an architecture review; this closure does not waive that gate.
+
+## Work Item 0.9.0-03: Unify Shared State And Actions
+
+### Objective
+
+Make package-neutral shared state, actions, operations, dependencies, and ownership authoritative after compatibility analysis, while preserving Context and Zustand source diagnostics.
+
+### Scope Boundary
+
+This item concerns reduced Context action specialization and reduced Zustand stores. Ordinary static build-time Context does not need to become shared browser state and must not be forced through `SharedStateIR`.
+
+### Current Duplication To Prove
+
+| Behavior | Context path | Zustand path |
+|---|---|---|
+| State-pair discovery | `resolveContextHook()` | `analyzeZustandStores()` |
+| Action capture validation | Context action analysis | Zustand action analysis |
+| State dependency discovery | `contextAction` descriptors | `sharedAction` descriptors |
+| Handler dispatch | Context AST clone/inlining | `sharedActionDispatch()` |
+| Concrete state ownership | Provider symbol ownership | Shared layout store identity |
+| Generic IR | Ordinary state/handler records | `SharedStateIR` and `SharedActionIR` |
+
+### Authorization Gate
+
+- 0.9.0-02 is complete.
+- A real fixture demonstrates duplicated source-model behavior.
+- The fixture requires shared action semantics, not ordinary static Context.
+- Current diagnostics and layout/route lifetime are recorded.
+
+### Session 03A: Equivalence Fixture And IR Snapshots
+
+1. Add equivalent Context and Zustand source variants for one behavior.
+2. Assert existing browser behavior before unification.
+3. Snapshot current ModuleIR differences.
+4. Add a static sibling to the Zustand fixture.
+5. Record layout, route, navigation, same-turn update, and effect behavior.
+6. Add a failing assertion for the intended package-neutral boundary.
+
+**Result:** complete on 2026-08-19.
+
+- Authorizing evidence: the existing reduced Context Notes and Zustand cart fixtures prove duplicated state/action discovery and lowering. Their original external upstream revisions were not recorded, so the equivalence fixture records the Kudzu commits that introduced and narrowed both reductions instead of inventing provenance.
+- Equivalent fixture: [`test/fixtures/context-shared-actions`](../../test/fixtures/context-shared-actions) reproduces the Zustand cart's object state, parameterized add/remove actions, two same-turn additions, batched dependency effect, retained layout DOM, enhanced navigation, and static sibling through the existing Context source boundary.
+- Current semantic equivalence: both variants emit one layout-owned `quantities` RouteIR state, the same selected `quantities.oak ?? 0` effect dependency, the same direct bindings, and the same navigation lifetime. Required Chrome proves `0 -> 2 -> 0`, one effect commit per synchronous turn, retained header identity, and current route consumers.
+- Recorded ownership limit: route consumers are replaced while the shared layout owner persists. The authored effect has no cleanup callback, so document/layout disposal cleanup remains unproven here and is reserved for Session 03E rather than implied by 03A.
+- Current ModuleIR difference: Context modules retain ordinary `module-symbol` signals, empty `sharedStates`/`sharedActions`, and empty handler action edges. Zustand modules retain one package-neutral `SharedStateIR`, one `SharedActionIR` per selected action, `shared-state` signals, and handler action slot `0`.
+- Intended boundary failure: one focused assertion compares source-model-neutral state, action, handler-action, and signal-kind projections for the Context and Zustand product/cart modules. It fails only because Context has not crossed the package-neutral shared-state/action boundary.
+- Static exclusion: both `/static` routes emit complete HTML with no script or state marker. Context and Zustand package references are absent from browser output.
+- Output accounting: the equivalent Context graph is 29,791 raw / 13,022 aggregate gzip JavaScript bytes; the Zustand graph is 30,131 raw / 13,150 aggregate gzip bytes. Both emit the same 18 deploy paths. Digests are `ba302120f5fe7584bbdaae8a0a8ccba08385f5108b713ba5101e4ed7bf1f45ed` and `86c13ffc95545c2ad02d752481d5ea63de16d4533322bdfbfd046b0dc87a3ad2` respectively.
+- Accounting: zero semantic primitives, ModuleIR record kinds, core passes, normalization entries, production compiler lines, runtime concepts, and browser-runtime bytes added. One positive equivalence fixture, two static sibling checks, current IR snapshots, and one expected-red boundary assertion were added.
+- Verification at `abe87ceafbf70ed8eb2618976e2d1e18c378126f`, Node 24.14.0, and Chrome 142.0.7444.175: `npm run check` passes; both focused required-Chrome behavior tests pass before the boundary assertion; the full suite reports 236 pass and the one authorizing failure out of 237 tests.
+
+Session 03B input:
+
+```text
+Authorizing fixture: equivalent Context/Zustand cart reduction
+First unsupported boundary: Context product/cart ModuleIR has no SharedStateIR, SharedActionIR, shared-state SignalIR, or HandlerIR action edge
+Canonical semantic reduction: existing SharedStateIR and SharedActionIR plus the existing validated handler operation reference, if sufficient
+Existing IR producer: Zustand adapter registration in source-compiler.mjs
+Existing IR consumers: descriptor-session.mjs, handler-lowering.mjs, and module-ir.mjs
+Owner and release boundary: one layout-owned state identity with route-owned action consumers and an existing layout dependency effect
+Nearby rejected forms: existing Context and Zustand negative boundaries remain unchanged
+Expected browser capability delta: none; RouteIR, runtime family, and browser state machinery are already equivalent
+```
+
+### Session 03B: Package-Neutral Action Contract
+
+Decide whether existing `SharedActionIR` plus structured `HandlerIR` operations is sufficient. Do not add a new action language if current command and handler semantics can represent the fixture.
+
+Required fields remain package-neutral:
+
+```text
+shared state identity
+target field/state
+operation identity
+structured state transition or validated handler operation reference
+owner/lifetime
+source provenance
+```
+
+Forbidden fields in generic IR:
+
+```text
+Zustand package names
+Context object names
+Provider implementation AST
+set callback spelling
+library selector syntax
+runtime subscription functions
+```
+
+**Result:** complete on 2026-08-19. Existing records are sufficient when read together: `SharedActionIR.state` is the deterministic shared-owner anchor, while the linked command or module-export `HandlerIR` owns the complete structured operation and ordered signal set. Multi-state Context actions therefore remain one action identity without adding a target-array schema. Context `SharedStateIR` records identity and field; Provider execution and RouteIR remain authoritative for the concrete initial value and lifetime. No action language, record kind, version change, or runtime concept is required.
+
+### Session 03C: Context Adapter Boundary
+
+Move only the reduced Context action output to package-neutral records. Preserve:
+
+- direct `useContext` source boundary;
+- one local or relative Context declaration;
+- one Provider;
+- direct shorthand Provider value;
+- exposed state requirement;
+- compiler-only action setters;
+- collision-free consumer aliases;
+- direct-call-only action use;
+- existing negative diagnostics.
+
+Do not turn general Context values into a store.
+
+**Result:** complete. Reduced Context consumers now register `SharedStateIR`, `SharedActionIR`, shared-state `SignalIR`, and handler action edges using the Provider's stable module-symbol identity. Provider `useState()` execution, ordinary Context rendering, compiler-only setters, collision aliases, and existing source diagnostics remain unchanged. Ordinary static Context values do not enter this path.
+
+### Session 03D: Generic Handler Consumption
+
+Converge `contextAction` and `sharedAction` only after adapters have produced equivalent package-neutral records.
+
+Expected generic consumers:
+
+```text
+framework/compiler/descriptor-session.mjs
+framework/compiler/handler-lowering.mjs
+framework/compiler/ir/module-ir.mjs
+```
+
+`core.mjs` and browser runtime should remain unchanged unless the fixture proves concrete state allocation cannot be represented today.
+
+**Result:** complete. `descriptor-session.mjs` discovers direct action dependencies from one package-neutral transient action descriptor, and `handler-lowering.mjs` consumes the same `sharedAction` entry for Context and Zustand. Direct command optimization retains its `HandlerIR.actions` edge. Provider/action AST and setter spelling remain source-local and do not enter finalized ModuleIR. `contextAction` branches were removed; `core.mjs`, RouteIR, capability planning, and browser runtimes did not change.
+
+### Session 03E: Ownership And Navigation Proof
+
+Required browser behavior:
+
+- same-turn actions see current logical state;
+- DOM writes remain batched;
+- layout-owned state persists through enhanced navigation;
+- route-owned consumers release correctly;
+- effects observe the same shared dependencies;
+- document/layout disposal cleans up once;
+- static siblings load no store or Context runtime;
+- package imports are absent from output.
+
+**Result:** complete. Required Chrome runs the same cart journey for both source models. Two same-turn additions produce one `0 -> 2` effect commit; dependency cleanup precedes `2 -> 0`; enhanced navigation retains the header and layout state; route consumers read the current value; non-persisted `pagehide` disposes the layout effect exactly once. Both static siblings remain complete zero-JavaScript HTML, and React, Context, and Zustand package references are absent from browser output.
+
+### Session 03F: Negative Boundary
+
+Keep or add fixed negatives for:
+
+- hidden action state;
+- exposed setter without state;
+- private captures;
+- dynamic Provider value;
+- multiple Providers;
+- indirect action alias;
+- dynamic store field;
+- derived/dynamic Zustand selector;
+- captured Zustand helper;
+- store initialization in keyed ownership;
+- action escape or callback registry use.
+
+**Result:** complete. Existing fixtures retain hidden-state, setter-only, private-capture, indirect-action, derived-selector, captured-helper, and action-escape diagnostics. Four focused fixtures add dynamic Provider values, multiple Providers, dynamic Zustand fields, and keyed-owner store calls. The keyed form remains rejected by the existing pure keyed-expression call boundary; no keyed shared-store semantics were added.
+
+### Session 03G: Shared-State Closure Report
+
+Expected result:
+
+```text
+Semantic primitives       +0
+Generic browser store     +0
+Subscription runtime      +0
+Package-specific IR       removed or contained
+Generic action consumers  shared
+Static sibling JS         0
+```
+
+**Result:** complete on 2026-08-19.
+
+```text
+Semantic primitives added:             0
+ModuleIR record kinds added/removed:    0 / 0
+Core passes added/removed:              0 / 0
+Ordered normalization entries:          0 / 0
+Runtime concepts added:                 0
+Generic store/subscription runtime:     0
+Production source net delta:            +26 lines
+Core semantic LOC delta for item 03:    +26 (5,140 -> 5,166)
+Core semantic LOC delta from 0.8.62:     +205 (4,961 -> 5,166)
+Compatibility LOC delta:                0
+Positive fixtures added:                1
+Negative fixtures added:                4
+Static sibling JavaScript:              0 B
+```
+
+- The Context and Zustand cart fixtures each emit the same 18 deploy paths before and after unification. With the final cleanup source, Context remains 29,951 raw / 13,065 aggregate gzip JavaScript bytes with digest `66897dce8fffd9e6bfb8b6a65ffba922a9f19d47dbb12c2a613dfb4b5685ee93`; Zustand remains 30,291 / 13,193 bytes with digest `9c157adc2ff9afef1c282d50cecf77f6c0d8be2251d996298155ffb396e50211`.
+- The maintained Worker/effect graph remains byte-identical at 907 raw / 477 gzip bytes and 13,786 raw / 5,931 gzip bytes. Same-host sequential diagnostics measured baseline median 631.5 ms and final-candidate median 456.6 ms at different times; the run was not interleaved, so it establishes no timing comparison or claim.
+- `npm run check`, 241/241 Node tests, 241/241 required-Chrome tests on Chrome 142.0.7444.175, and packed-package smoke pass on Node 24.14.0. The package smoke installs four packages and builds one static page with zero interactive pages.
+- The +26 item LOC and cumulative +205 core LOC remain explicit debt for Work Item 0.9.0-06; this closure does not waive the final baseline gate.
+
+## Work Item 0.9.0-04: Generalize Resource Ownership
+
+### Objective
+
+Determine whether existing effect ownership is sufficient for realistic resource-heavy applications, consolidate lifecycle proof where evidence supports it, and avoid `ResourceIR` unless multiple real cross-owner fixtures prove a missing semantic concept.
+
+### Starting Position
+
+Existing fixtures already represent:
+
+- WebSocket;
+- Worker;
+- terminal/SDK-like async acquisition;
+- timers;
+- animation frames;
+- `IntersectionObserver`;
+- canvas;
+- package-owned browser modules;
+- document listeners;
+- media query subscriptions.
+
+They currently fit `EffectIR`, authored setup closures, exact cleanup, owner invalidation, and effect-private refs. Therefore the default expected result is no `ResourceIR`.
+
+### Session 04A: Lifecycle Matrix
+
+Create a matrix for every existing resource fixture:
+
+| Field | Required evidence |
+|---|---|
+| Acquire | Exact creation or subscription site |
+| Dependencies | State/prop inputs causing replacement |
+| Owner | Document, layout, route, conditional, or keyed owner |
+| Invalidation | When setter/ref authority ends |
+| Cleanup | Exact close, terminate, cancel, disconnect, remove, or destroy operation |
+| Late completion | Behavior after invalidation |
+| BFCache | Persisted pagehide/pageshow behavior where relevant |
+| Static exclusion | Static sibling and package/chunk absence |
+
+**Result:** complete on 2026-08-19. The full matrix is recorded in [`0.9-resource-lifecycle.md`](./0.9-resource-lifecycle.md).
+
+- Worker, WebSocket, async terminal, timers, animation frames, observer/canvas, document listeners, media-query subscriptions, navigation layout resources, and package-owned effect modules were inventoried against acquire, dependencies, owner, invalidation, cleanup, late completion, BFCache, and static exclusion.
+- Every represented resource remains private to one effect invocation or an existing route/layout/conditional owner. No fixture proves handler/effect sharing, independent subscribers, reconnect state shared across owners, or ownership outside the acquiring effect.
+- Strong required-Chrome evidence exists for Workers, timers, animation frames, canvas/observer, listeners, media queries, route/layout navigation, stale writes, and repeated disposal.
+- WebSocket replacement is executable only with a Node fake. Terminal acquisition/BFCache behavior and package-effect cleanup remain build-only. No maintained journey proves genuine browser BFCache restoration.
+- The gaps map directly to Session 04B. Session 04A changes documentation only and adds zero semantic primitives, IR kinds, passes, runtime concepts, browser files, or bytes.
+
+### Session 04B: Close Existing Behavioral Gaps
+
+Prioritize tests, not new semantics:
+
+1. Add executable terminal async acquisition and BFCache checks if the fixture can run deterministically.
+2. Add a browser WebSocket ownership journey using a deterministic fake transport where appropriate.
+3. Combine dependency replacement, navigation owner release, and late completion in one fixture.
+4. Verify route-owned package resource cleanup and package exclusion.
+5. Record raw/gzip capability bytes.
+
+**Result:** complete on 2026-08-19.
+
+- The terminal fixture now has two deterministic required-Chrome scenarios. One proves accepted async acquisition, persisted hide/show resume, exact discard cleanup, listener removal, and idempotent disposal. The other resolves acquisition after disposal and proves the late handle closes once without publishing ready state.
+- The WebSocket fixture now uses an enhanced-navigation layout. One required-Chrome journey combines `general -> support` dependency replacement, exact listener removal/close, stale callback rejection, route release, retained layout identity, fresh back-navigation ownership, and idempotent document disposal.
+- The package effect's setup and cleanup now execute in Chrome. The static sibling remains script- and package-free. The fixture still creates no package handle, so actual package-created resource cleanup remains evidence-blocked rather than simulated.
+- Aggregate JavaScript graphs are: terminal 2,634 raw / 1,495 gzip bytes; WebSocket 15,872 / 7,163 bytes; package effect 3,562,795 / 1,025,300 bytes. No dedicated resource runtime or shared browser bytes were added.
+- Production compiler, ModuleIR, RouteIR, runtime concepts, and accepted source syntax are unchanged. The changes are fixture-local behavior and browser evidence only.
+
+### Session 04C: Common Lifecycle Proof Review
+
+Inventory duplicated recognition for:
+
+- add/remove listener pairs;
+- schedule/cancel pairs;
+- observe/disconnect pairs;
+- create/destroy or close pairs;
+- async generation invalidation;
+- private mutable handle ownership.
+
+Only extract a shared source-local proof helper when at least two existing passes perform the same lexical ownership check and the extraction reduces code without weakening diagnostics.
+
+A private analysis result may describe acquire/cleanup correspondence. It does not become public IR or browser runtime state unless required by independently proven semantics.
+
+**Result:** complete on 2026-08-19. The only exact duplicate was an inclusive AST ancestry predicate in effect-private refs, effect resource validation, media-query normalization, and command-helper validation. One `isNodeWithin()` helper replaces all four copies, reducing the five changed compiler files by 12 net lines while preserving every source-specific diagnostic. Listener, timer, frame, observer, handle, and generation recognizers remain focused because their source graphs and proof obligations differ.
+
+### Session 04D: Qualifying Cross-Owner Fixture Decision
+
+`ResourceIR` review requires at least three unrelated real fixtures whose lifetimes cannot fit effect-private ownership. Qualifying pressure may include:
+
+- one layout transport with independently mounted subscribers;
+- intentional handler and effect sharing of one handle;
+- reconnect/replay state shared across route owners;
+- one resource whose owner differs from the effect invocation that acquires it.
+
+Non-qualifying pressure includes:
+
+- a private SDK handle;
+- one WebSocket in one effect;
+- one observer with cleanup;
+- one timer or animation frame;
+- library-specific constructor syntax;
+- a desire to expose a public resource API.
+
+**Result:** complete. Zero maintained fixtures qualify. The navigation layout transport and route chart subscription are the closest case, but each lifetime decomposes cleanly into one layout `EffectIR` and one route `EffectIR` with independent cleanup. Surveyed Mattermost/Twenty transport pressure remains external research rather than a reduced failing fixture. `ResourceIR` review is not authorized.
+
+### Session 04E: Decision Record
+
+Close the item with one of two outcomes.
+
+**Expected outcome A:** Existing EffectIR is sufficient. Record improved lifecycle coverage, any deleted duplication, zero runtime concepts, and no ResourceIR.
+
+**Exceptional outcome B:** Architecture review approves a narrow resource record after three qualifying fixtures. Record why EffectIR cannot represent ownership, why normalization cannot solve it, exact fields, codegen consumers, browser-byte impact, and rejected generic-runtime alternatives.
+
+**Result:** complete with expected outcome A. Existing `EffectIR`, invocation-private closures, and document/layout/route/conditional/keyed ownership represent every maintained fixture. Sessions 04A-04D add browser evidence and remove 12 lines of duplicate lexical proof, with zero semantic primitives, ModuleIR kinds, passes, runtime concepts, public APIs, or browser bytes.
+
+```text
+Semantic primitives added:             0
+ModuleIR record kinds added/removed:    0 / 0
+Core passes added/removed:              0 / 0
+Ordered normalization entries:          0 / 0
+Runtime concepts added:                 0
+Production compiler LOC delta:          -12
+Core semantic LOC delta for item 04:    -3 (5,166 -> 5,163)
+Core semantic LOC delta from 0.8.62:     +202 (4,961 -> 5,163)
+Browser runtime byte delta:             0 B
+```
+
+- `npm run check`, 241/241 Node tests, 241/241 required-Chrome tests on Chrome 142.0.7444.175, and package smoke pass on Node 24.14.0.
+- The maintained Worker graph remains 907 raw / 477 gzip bytes and the window graph remains 13,786 / 5,931 bytes. One warm-up and seven final-candidate builds measured `[686.6,606.6,707.7,615.3,512.8,504.2,536.7]` with median 606.6 ms; this same-target diagnostic makes no comparative timing claim.
+- The cumulative +202 core semantic LOC remains debt for Work Item 0.9.0-06; resource closure reduces that debt by three core-file lines and does not waive the final baseline gate.
+
+## Work Item 0.9.0-05: Strengthen Component Ownership And Dependencies
+
+### Objective
+
+Allow ordinary component boundaries to survive authoring while object-property dependencies, state operations, refs, effects, and repeated ownership remain compile-time facts.
+
+### Authorization Gate
+
+- 0.9.0-04 is closed.
+- A real application fixture currently requires component flattening or artificial primitive-state decomposition.
+- The unsupported source uses ordinary React component, prop, and hook patterns.
+- Existing direct prop and specialization rules cannot represent it safely.
+
+### Required Authorizing Fixture
+
+The preferred fixture shape is:
+
+```text
+Parent object state
+  -> immutable object prop
+     -> Child A reads field A in text/attribute
+     -> Child B reads field B in an effect
+     -> Child C reads collection field C in a keyed list
+```
+
+The browser journey must replace the parent object so one field changes while another remains equal. Only proven consumers update or rerun.
+
+### Session 05A: Fixture And Ownership Baseline
+
+1. Pin real upstream source.
+2. Preserve component boundaries in the reduced fixture.
+3. Add repeated component instances.
+4. Add one conditional instance.
+5. Add effect cleanup and remount checks.
+6. Add DOM identity checks.
+7. Add a static sibling.
+8. Record current failure and any flattening workaround.
+
+**Result:** complete on 2026-08-19.
+
+- [`object-prop-workledger-conversation`](../../test/fixtures/object-prop-workledger-conversation) pins MIT-licensed WorkLedger revision `3d8bf2130ec1d7698bff07fb00726b2bb94d20d4`, the complete archive hash, source hashes, and license hash.
+- The upstream state is owned by `useAIConversation()`, passed intact from `AISidebar` to `AIConversation`, selected as `[conversation.messages, streamContent]`, and mapped into keyed message rows. The reduction removes the custom hook, AI providers, storage, streaming, unrelated callbacks, and styling while preserving that semantic path.
+- Two retained and one conditional `ConversationView` invocation establish repeated ownership. The fixture includes selected-property effect cleanup counters, keyed rows, same-collection and replaced-collection updates, DOM identity targets, and a static sibling.
+- The first current failure is `src/ConversationView.tsx:11:3 useEffect() item-property dependencies are only supported in direct keyed row components`. Flattening the child or decomposing `conversation` into `label` and `messages` props avoids it but violates the authorization goal.
+- The post-05B browser contract is pinned in the fixture README: retained collection identity suppresses unrelated effect/list work, collection replacement reruns each owned effect once while preserving retained keys, conditional release/remount is exact, final disposal is idempotent, and `/static` remains zero JavaScript.
+- Session 05A adds no semantic primitive, IR kind, compiler pass, runtime concept, public API, or browser bytes. The fixture remains an expected build failure until Session 05B defines the property dependency contract.
+- `npm run check`, 242/242 Node tests, 242/242 required-Chrome tests on Chrome 142.0.7444.175, package smoke, and `git diff --check` pass. No benchmark or artifact delta is claimed because production compiler and runtime files are unchanged and the authorizing route intentionally emits no output yet.
+
+### Session 05B: Property Dependency Contract
+
+The semantic link must identify:
+
+```text
+source SignalIR
+static property path
+component specialization owner
+consumer kind
+selected equality behavior
+conditional/keyed release owner when present
+```
+
+Do not create field-level mutable state slots solely to make analysis easier. One application object remains one logical state value unless authored otherwise.
+
+**Result:** complete on 2026-08-19. [`0.9-component-property-contract.md`](./0.9-component-property-contract.md) defines one specialization-owned property link containing the existing parent SignalIR slot, one non-empty safe static path, `binding`/`effect`/`list` consumers, and `Object.is` selected equality. Bindings reuse `BindingIR`, effects reuse expression `DerivedIR`, and lists reuse binding-backed `KeyedBlockIR` plus the existing compiler-owned array anchor. No field signal, ModuleIR kind, runtime concept, or browser component owner is authorized.
+
+### Session 05C: ComponentAnalysis Producer
+
+Expected narrow owner:
+
+```text
+framework/compiler/analysis/component-analysis.mjs
+framework/compiler/source-compiler.mjs specialization path
+framework/compiler/ir/module-ir.mjs validation
+```
+
+Required properties:
+
+- JSON-safe references after source-local analysis;
+- stable OwnerRef and SignalIR links;
+- no retained component instance;
+- repeated calls own independent child state/effects;
+- direct parent state remains shared where semantically authored;
+- static property paths only;
+- no arbitrary object mutation tracking.
+
+**Result:** complete. Each direct object-state prop specialization records JSON-safe `{ signal, path, consumers, equality }` property links under its existing prop entry. The signal is the already-authoritative parent SignalIR, the path is one safe direct segment, and the containing specialization remains the owner. ModuleIR validation checks every signal and boundary after JSON round-tripping. Repeated calls receive distinct specialization owners while sharing the one authored parent state.
+
+### Session 05D: Binding And Effect Consumers
+
+Reuse existing Derived and effect dependency semantics from 0.9.0-02.
+
+Required behavior:
+
+- property equality suppresses unrelated effect reruns;
+- direct DOM binding updates target only known nodes;
+- conditional removal releases state, refs, handlers, and effects;
+- remount recreates child-owned state from the authored initializer;
+- parent object identity changes do not force generic component rerendering.
+
+**Result:** complete. Direct scalar fields reuse existing binding evaluators. Direct array fields become binding-backed keyed collections with existing compiler-owned anchors. Selected array effects reuse expression DerivedIR and `Object.is`, extending only the existing expression value guard from primitive to primitive-or-array. A compiler-only null-returning effect helper preserves each component invocation boundary while the authored component and helper disappear from browser ESM. Required Chrome proves same-array replacement updates labels without effect reruns, new-array replacement performs one cleanup/setup per owner, retained keys preserve DOM identity, conditional release/remount is exact, and final disposal is idempotent.
+
+### Session 05E: Callback And Operation Boundaries
+
+Do not remove the existing three-boundary callback limit speculatively. Extend only when the real fixture requires another direct forwarding boundary and ownership remains statically proven.
+
+Keep rejected:
+
+- callback aliases;
+- dynamic callback selection;
+- callback registries;
+- repeated calls in one handler where unsupported;
+- unproven spreads;
+- callback use outside supported event/effect roles;
+- a generic function serialization mechanism.
+
+**Result:** complete with no change. The WorkLedger reduction owns updates in the parent and requires no callback forwarding extension. Existing three-boundary callback limits and diagnostics remain intact.
+
+### Session 05F: Negative Boundary
+
+Required negatives:
+
+- dynamic property access;
+- object mutation;
+- opaque object spread;
+- property alias that loses ownership proof;
+- composed initializer outside the proven boundary;
+- callback alias or escape;
+- hookful child on an unproven dynamic path;
+- object ref forwarded to multiple roots;
+- fourth callback boundary unless separately authorized;
+- whole-object dependency where only property semantics are supported.
+
+**Result:** complete. New focused fixtures reject dynamic selected paths, property aliases, and prop mutation. Existing dynamic component spreads, composed child initializers, callback escape/fourth-boundary cases, dynamic hook paths, repeated-root ref diagnostics, mixed whole-object/property dependency tests, and collection mutation diagnostics retain the remaining boundary. The positive trigger requires one direct parent state identifier and one direct `prop.field.map()` consumer, so object expressions and opaque call-site values do not acquire property links.
+
+### Session 05G: Specialization Cache Decision
+
+Do not add caching because repeated components exist. Add it only when a maintained fixture proves repeated semantic analysis is material.
+
+Required cache proof:
+
+- stable semantic input key;
+- no AST mutation sharing;
+- source dependency invalidation;
+- ownership IDs remain call-site specific;
+- output is byte-identical;
+- clean and incremental build improvement is material under the protocol.
+
+**Result:** complete with no cache. Three repeated WorkLedger calls do not establish material analysis cost, and call-site-specific ownership IDs prevent an unmeasured AST-result cache from being free. Existing project/module caches remain unchanged.
+
+**Work item result:** complete on 2026-08-19.
+
+```text
+Semantic primitives added:             0
+ModuleIR record kinds added/removed:    0 / 0
+Core passes added/removed:              0 / 0
+Ordered normalization entries:          0 / 0
+Runtime concepts added:                 0
+Browser component functions added:      0
+Positive / negative fixtures added:     1 / 3
+Browser runtime byte delta:             0 B
+Production compiler LOC delta:          +133
+Core semantic LOC delta for item 05:    +133 (5,163 -> 5,296)
+Core semantic LOC delta from 0.8.62:     +335 (4,961 -> 5,296)
+```
+
+- WorkLedger route graph: 11 JavaScript files, 37,302 raw / 14,083 aggregate gzip bytes; `/static` emits zero JavaScript.
+- Maintained Worker/effect graph remains 907 raw / 477 gzip bytes for Worker and 13,786 / 5,931 bytes for window output. One warm-up and seven same-target completion builds measured `[1162.6,1505.3,1140.8,938.0,758.9,753.8,717.3]`, median 938.0 ms; no timing comparison is claimed.
+- `npm run check`, 245/245 Node tests, 245/245 required-Chrome tests on Chrome 142.0.7444.175, package smoke, and `git diff --check` pass.
+- The +133 item delta and cumulative +335 core semantic LOC remain explicit debt for Work Item 0.9.0-06. The final baseline gate requires deletion or architecture review; this work item does not waive it.
+
+## Work Item 0.9.0-06: Remove Duplication And Close Semantic Compression
+
+### Objective
+
+Delete syntax-specific analysis made redundant by 0.9 semantic authority, reduce or hold pass and LOC counts, and preserve diagnostic ownership.
+
+### Candidate Duplication Inventory
+
+Candidates are reviewed, not automatically removed:
+
+| Candidate | Evidence required |
+|---|---|
+| Context versus shared-action branches | Both adapters already produce equivalent generic records |
+| Binding/imported calculation versus Derived identity | Consumers already use one canonical derived representation |
+| Listener pair validation | At least two passes use identical lexical ownership proof |
+| Animation cancellation validation | Duplicate proof can be removed without weakening specialized diagnostics |
+| Primitive/object/array initializer checks | One serializable initializer contract preserves authored limits |
+| Setter/reducer/state-backed specialization loops | One semantic operation edge preserves all negative boundaries |
+| Derived diagnostic string rewriting | Context-aware diagnostics can replace message mutation |
+| Route dependency denormalization | Direct references survive into route planning without changing RouteIR behavior |
+
+### Session 06A: Candidate Ledger
+
+For each candidate record:
+
+```text
+Current producers:
+Current consumers:
+Duplicate semantic decision:
+Required source-specific diagnostic:
+Deletion enabled by completed work:
+Expected LOC/pass delta:
+Regression fixtures:
+```
+
+Reject candidates that merely move code or hide pass count.
+
+**Result:** complete on 2026-08-19. [`0.9-compression-ledger.md`](./0.9-compression-ledger.md) records all eight planned candidates plus the Work Item 05 component-helper duplication. Context/shared actions and resource proof are already compressed; listener, animation, broad specialization-loop, diagnostic-rewording, and route-denormalization candidates would only move code or weaken authority. Serializable initializer lookup remains a viable later deletion. The first selected candidate is the exact compiler-only component effect helper materialization duplicated by object-property and setter-callback specialization.
+
+### Session 06B: One Deletion At A Time
+
+Each deletion is independently reviewable and runs:
+
+- focused positive tests;
+- focused negative tests;
+- `npm run check`;
+- `npm test`;
+- required Chrome tests;
+- output manifest comparison;
+- raw/gzip comparison;
+- affected benchmark.
+
+Do not batch unrelated cleanup into one change.
+
+**First deletion result:** complete. One `materializeComponentHelper()` replaces duplicated effect rewriting, authored-source retention, helper declaration registration, setter/state-owner map installation, and capability flags in `source-compiler.mjs`. Object-property specialization still prepends a null helper to retain visible list analysis; setter specialization still replaces its root with the state-owning helper. No diagnostic, accepted source, pass, IR, runtime, or browser output changes.
+
+```text
+Core semantic LOC:              5,296 -> 5,271 (-25)
+Core semantic LOC from 0.8.62:  +310 (4,961 -> 5,271)
+Production files changed:       1
+Browser runtime byte delta:     0 B
+```
+
+- WorkLedger and array-prop effect-sync deploy digests and raw/gzip JavaScript are byte-identical before and after the deletion; exact values are in the compression ledger.
+- `npm run check`, all 245 Node tests, all 245 required-Chrome tests, and fresh-install package smoke pass. The maintained Worker/effect graph remains 907 raw / 477 gzip B for Worker and 13,786 raw / 5,931 gzip B for window output; seven same-target builds have a 444.7 ms median, with no comparative timing claim.
+
+**Second deletion result:** complete. `directStateInitializer()` now performs the single direct serializable `useState()` declaration lookup used by parameterized debounce validation, setter-child array effect pairing, and specialized child state seeding. Primitive and array restrictions remain at their callers; two duplicate component-body scans are removed.
+
+```text
+Core semantic LOC:              5,271 -> 5,264 (-7)
+Total Session 06B deletion:     5,296 -> 5,264 (-32)
+Core semantic LOC from 0.8.62:  +303 (4,961 -> 5,264)
+Production files changed:       1
+Browser runtime byte delta:     0 B
+```
+
+- Parameterized-debounce and array-prop effect-sync deploy trees are byte-identical against the preceding commit; exact digests and raw/gzip JavaScript are in the compression ledger.
+- `npm run check`, all 245 Node tests, all 245 required-Chrome tests, and package smoke pass. The maintained Worker/effect graph remains byte-identical; seven same-target builds have a 507.7 ms median, with no timing claim.
+- No remaining ledger candidate offers meaningful source deletion without moving source-specific proof, weakening ownership authority, or adding a diagnostic abstraction. Session 06B is complete.
+
+### Session 06C: Diagnostic Audit
+
+Verify every newly supported boundary reports:
+
+- stable semantic reason;
+- authored file, line, and column;
+- supported neighboring forms;
+- safe migration direction;
+- no generated `.kudzu` path as the primary location;
+- no silent fallback.
+
+**Result:** complete. Six object-property, setter-effect, and debounce invalid fixtures were built against the preceding commit and final candidate. Relative authored file, line, column, and message are identical after normalizing the checkout root; only expected internal stack-frame line numbers move. Every message retains its semantic reason and nearby safe form. No generated path is primary, no fallback exists, and no diagnostic abstraction was added. Exact messages are recorded in the compression ledger.
+
+### Session 06D: Final Complexity Comparison
+
+Repeat every 0.9.0-01 count using the same commands and file sets.
+
+Required table:
+
+| Metric | 0.8.62 baseline | 0.9 candidate | Delta | Explanation |
+|---|---:|---:|---:|---|
+| Semantic concepts | 10 | 10 | 0 | The existing kernel remains sufficient; Resource stays effect-owned. |
+| ModuleIR record kinds | 10 | 10 | 0 | Existing Signal, Derived, SharedAction, Effect, and ownership records are reused. |
+| Core semantic passes | 5 | 5 | 0 | Binding index, transformer, and three structural/projection boundaries remain distinct. |
+| Ordered normalization entries | 15 page / 14 imported | 15 page / 14 imported | 0 / 0 | No pass was added or hidden in the transformer. |
+| Core semantic LOC | 4,961 | 5,317 | +356 | Proven semantics add 335 lines, Session 06B removes 32, and measured Work Item 07 scaling paths add 53. |
+| Compatibility LOC | 1,342 | 1,333 | -9 | Shared ancestry proof removed duplicate adapter checks. |
+| Runtime concepts | 10 | 10 | 0 | Existing capability modules implement every accepted slice. |
+| Browser bytes by family | Recorded baseline | Unchanged for baseline families | 0 B | New fixtures select existing route-specific families only. |
+| Positive fixtures | 0 added | 4 added | +4 | Two Derived, one shared-action, and one object-property fixture. |
+| Negative fixtures | 0 added | 7 added | +7 | Four shared-action/store and three object-property boundaries. |
+
+If core semantic LOC or pass count increases, release requires an explicit architecture review documenting why the increase is necessary, what duplication was removed, and why the result remains bounded.
+
+**Architecture review:** approved for the current 0.9 candidate. The +356 core lines implement three evidence-backed closures plus 53 lines of measured Work Item 07 import-free graph, used-import, and async compilation paths. Session 06B removes 32 duplicate lines after the semantic seams become visible. The increase remains bounded because it adds zero concepts, record kinds, passes, normalization entries, runtime concepts, or public APIs; every new boundary is covered by real positive and fail-closed negative fixtures. The candidate ledger rejects consolidations that merely move code or erase source-specific proof.
+
+The maintained public storefront scaling gate passes at 100, 1,000, and 10,000 generated products against preceding commit `bb7fdc5`. All three paired baseline/candidate manifests and byte counts are identical. Seven alternating clean-build samples per target overlap, so no timing change is claimed; medians, output sizes, and raw samples are recorded in `PERFORMANCE.md` and the compression ledger.
+
+## Work Item 0.9.0-07: Final Cross-Framework Proof
+
+**Status:** complete. Local benchmark source remains ignored by project policy. Native C1 disclosure and the C2/C5 stateful, Worker, navigation, ownership, static-exclusion, resilience, and uniform metric matrices pass. The final 21-profile C2 row filter is faster than Vue, while row restore and search restore are within 3.5% and 1.8% of their nearest comparators. Flattened generated commerce input plus one-shot plan streaming, release, and staged HTML spooling makes Kudzu 2.5%/5.5% faster than Astro cold/warm at 10,000 products and cuts peak RSS 71.0% to 542,484 KiB versus Astro's 612,412 KiB. Model-driven AI delivery is a 1.0 gate. See [`0.9-final-proof-audit.md`](./0.9-final-proof-audit.md).
+
+### Objective
+
+Run the complete matched suite and prove the browser, interaction, resilience, and build advantages required for `0.9.0`.
+
+### Comparison Set
+
+Minimum applicable set:
+
+| Category | Required comparator |
+|---|---|
+| Migration baseline | React + Vite |
+| Client framework | Vue |
+| Compiler framework | Svelte |
+| HTML-first/static | Astro |
+| Production static routing | Best applicable of Next.js, Nuxt, SvelteKit, React Router, or TanStack |
+
+Framework versions are pinned from lockfiles. Version changes after baseline require rerunning all affected targets.
+
+### Required Application Matrix
+
+| Application | Required characteristics |
+|---|---|
+| Content application | Multiple routes, links, metadata, CSS, assets, progressive enhancement, at least one small interaction |
+| Stateful application | Local state, derived state, shared state, forms, keyed collections, effects, cleanup, navigation |
+| Commerce scale application | 100, 1,000, and 10,000 generated products/routes with deterministic data |
+| Resource scenario | Worker, WebSocket, observer, canvas, or SDK-like lifetime with exact cleanup |
+
+One application may satisfy multiple rows, but content and stateful proof cannot both be replaced by one microbenchmark.
+
+### Behavior Acceptance Before Timing
+
+Every variant must pass:
+
+- complete initial content;
+- route and data parity;
+- form and validation behavior;
+- keyboard journeys;
+- focus behavior;
+- accessible names, roles, states, and errors;
+- keyed identity where the application requires it;
+- effect/resource cleanup;
+- back/forward and direct-entry behavior;
+- deterministic data and output expectations;
+- no uncaught browser errors.
+
+Failed acceptance means no timing sample is counted.
+
+### Artifact Measurements
+
+Record per route and complete session:
+
+- HTML raw/gzip;
+- CSS raw/gzip;
+- JavaScript raw/gzip;
+- actual browser-transferred JavaScript;
+- unique session JavaScript;
+- preload/module graph;
+- route count;
+- output file count;
+- total output size;
+- static-route JavaScript;
+- hydration markers or runtime bootstrap where applicable.
+
+### Browser Measurements
+
+Record:
+
+- first content visibility;
+- content readiness;
+- action readiness;
+- event-to-next-paint for representative actions;
+- navigation content and action readiness;
+- impatient-click loss from early interaction attempts;
+- main-thread script parse/execute cost;
+- heap after load;
+- heap after complete journey;
+- heap after repeated navigation/disposal;
+- browser exceptions and failed requests.
+
+### Failure-Resilience Matrix
+
+| Condition | Required expectation |
+|---|---|
+| JavaScript disabled | Native links/forms/content remain usable where baseline behavior permits |
+| JavaScript delayed two seconds | Complete HTML remains visible; early native behavior remains safe |
+| One capability chunk missing | Unrelated document behavior remains intact; failure is observable |
+| Slow 4G | No hidden hydration blank or unusable shell |
+| CPU throttled | Initial HTML remains available; interaction measurements are recorded |
+| Navigation fetch failure | Native recovery or explicit failure path remains available |
+
+### Build-Scaling Protocol
+
+Run 100, 1,000, and 10,000 deterministic products/routes.
+
+Required outputs:
+
+- actual emitted route count;
+- one warm-up;
+- at least seven rotating samples per target;
+- cold and warm build where supported;
+- raw timing arrays;
+- median, min, max, and paired differences where applicable;
+- peak RSS;
+- milliseconds per emitted route;
+- files and output bytes;
+- output digest or deterministic manifest;
+- acceptance result before timing;
+- framework and environment versions.
+
+Do not use three sequential samples for the release claim. Do not divide by requested product count when emitted route counts differ.
+
+### Tie And Loss Rules
+
+Deterministic byte metrics have no statistical tie: fewer bytes wins.
+
+Timing ties require:
+
+- interleaved or rotating target order;
+- at least seven samples;
+- at least twenty-one samples when ranges overlap or conclusions remain unstable;
+- no established median loss greater than the 5% materiality threshold;
+- a reported uncertainty method and raw samples;
+- no wording stronger than the evidence supports.
+
+A primary metric loss cannot be hidden in a weighted aggregate score.
+
+### 0.9 Competitive Pass Conditions
+
+Kudzu must show:
+
+- least initial JavaScript among applicable variants, accepting a tie only at the 0 B floor;
+- least total-session JavaScript among applicable variants, accepting a tie only at the 0 B floor;
+- no hydration;
+- fastest or statistically tied-fastest interaction readiness;
+- fastest or statistically tied-fastest representative event latency;
+- fastest or statistically tied-fastest matched navigation readiness;
+- no material CPU or heap loss;
+- stronger disabled/delayed/missing-JS behavior;
+- no material build-scaling weakness at 100, 1,000, or 10,000 routes;
+- complete behavior and accessibility parity.
+
+Any failure blocks release until fixed, invalidated by a corrected benchmark, or explicitly removed from the release claim with product approval.
+
+## Continuous Regression Matrix
+
+Every semantic work item selects the smallest relevant matrix, while the release candidate runs all rows.
+
+| Area | Focused | Full Node | Chrome | Output | Bytes | Build | Browser perf | Cross-framework |
+|---|---|---|---|---|---|---|---|---|
+| Baseline docs | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
+| Derived | Yes | Yes | Yes | Yes | Yes | Affected | Affected | Final |
+| Shared state | Yes | Yes | Yes | Yes | Yes | Affected | Affected | Final |
+| Resource | Yes | Yes | Yes | Yes | Yes | Affected | Required | Final |
+| Component | Yes | Yes | Yes | Yes | Yes | Affected | Required | Final |
+| Duplication deletion | Yes | Yes | Affected | Yes | Yes | Affected | Affected | Final |
+| Release candidate | All | All | All | All | All | All | All | All |
+
+## Fixture Evidence Standard
+
+Every new real-derived fixture records:
+
+```text
+Fixture name:
+Upstream project:
+Upstream URL:
+Upstream commit/tag:
+License:
+Acquisition hash:
+Original files:
+Reduced files:
+Behavior retained:
+Behavior deliberately excluded:
+First Kudzu failure:
+Semantic concept exercised:
+Static sibling:
+Positive browser journey:
+Negative neighboring forms:
+Artifact and byte result:
+Benchmark result:
+```
+
+Fixture count does not authorize a primitive. The semantic relationship between fixtures must be documented.
+
+## Diagnostic Standard
+
+0.9 diagnostics remain deterministic and actionable even before the structured 0.11 CLI work.
+
+Every new diagnostic answers:
+
+```text
+What source form failed?
+Which semantic proof is missing?
+Which forms are supported?
+What safe rewrite is possible?
+Where is the authored source location?
+```
+
+Preferred message shape:
+
+```text
+Cannot prove <semantic ownership or dependency>.
+
+<Specific authored construct> uses <unsupported behavior>.
+
+Supported forms:
+- <form>
+- <form>
+
+Possible migration:
+- <deterministic rewrite>
+```
+
+Do not expose generated paths, internal slots, or transient AST terminology as the primary explanation.
+
+## Per-Session Workflow
+
+### Start
+
+1. Read the required documents.
+2. Inspect `package.json` for the actual version.
+3. Inspect `git status` and preserve unrelated changes.
+4. Find the first incomplete work item and session packet.
+5. Verify dependencies and fixture evidence.
+6. Reproduce the current failure or baseline.
+7. Write the per-slice contract before editing production code.
+
+### Implement
+
+1. Choose the first applicable rung: native, existing semantics, normalization, adapter, architecture review.
+2. Add the smallest failing positive or negative check.
+3. Change the narrowest producer/consumer boundary.
+4. Preserve source-specific diagnostics at the compatibility boundary.
+5. Preserve JSON-safe IR and fail-closed validation.
+6. Avoid unrelated cleanup.
+7. Compare output before adding further scope.
+
+### Verify
+
+1. Run focused tests.
+2. Run `npm run check`.
+3. Run `npm test`.
+4. Run required Chrome tests.
+5. Run package smoke when package output changes.
+6. Compare representative ModuleIR and RouteIR.
+7. Compare emitted files and hashes.
+8. Record raw/gzip browser bytes.
+9. Run affected build/browser benchmarks.
+10. Confirm static siblings remain zero JavaScript.
+
+### Close
+
+1. Fill the complexity report.
+2. Record commands, environment, raw data, and limitations.
+3. Update the active work status.
+4. Update current architecture only when ownership actually moved.
+5. Update public support docs only for completed support.
+6. Do not update release notes or package version before release.
+7. Name the next exact session packet.
+
+## Per-Slice Completion Report Template
+
+```text
+Work item:
+Authorizing fixture:
+Upstream revision:
+First failing source location:
+
+Semantic reduction:
+Producer changed:
+Consumers changed:
+Ownership boundary:
+Nearby rejected forms:
+
+Semantic primitives added:
+ModuleIR records added/removed:
+Core passes added/removed:
+Ordered normalization entries added/removed:
+Core semantic LOC delta:
+Compatibility LOC delta:
+Runtime concepts added:
+
+Browser files changed:
+Browser raw byte delta:
+Browser gzip byte delta:
+Static sibling JavaScript:
+
+Positive fixtures added:
+Negative fixtures added:
+Focused tests:
+Full tests:
+Chrome journeys:
+Package smoke:
+
+Build benchmark:
+Browser benchmark:
+Cross-framework impact:
+Known limitations:
+Next work item:
+```
+
+## Architecture Review Triggers
+
+Stop implementation and open an architecture review when any condition is true:
+
+- one feature changes three or more unrelated core compiler subsystems;
+- a new semantic primitive is proposed;
+- a new ModuleIR record kind is proposed;
+- a browser runtime concept is proposed;
+- static routes would acquire JavaScript;
+- route JavaScript would include unused package behavior;
+- a generic callback registry is proposed;
+- a generic subscription/store/resource/query/form runtime is proposed;
+- arbitrary JavaScript evaluation or bytecode is proposed;
+- ownership cannot be expressed with current route/layout/conditional/keyed/effect boundaries;
+- output bytes materially increase;
+- a browser or build benchmark regresses materially;
+- diagnostics would require silent fallback;
+- a compatibility feature cannot remain at the adapter boundary.
+
+The review must compare deletion, native migration, normalization, adapter, existing IR extension, and rejection before considering a primitive.
+
+## Stop And Rollback Rules
+
+- Stop a semantic slice when no real fixture authorizes it.
+- Stop resource work when existing EffectIR already represents the fixture.
+- Stop caching work when no benchmark proves material repeated work.
+- Stop pass consolidation when diagnostic ownership becomes less clear.
+- Stop cross-framework sampling when behavior parity fails.
+- Stop a release claim when raw data is unavailable.
+- Stop package publication when version, tests, package smoke, registry verification, or performance gates differ from the reviewed commit.
+- Forward-fix published releases; never repoint a published tag.
+
+## Risk Register
+
+| Risk | Early signal | Mitigation | Release effect |
+|---|---|---|---|
+| Derived becomes arbitrary evaluator | New calls/operators added per fixture | Keep tagged pure vocabulary and static captures | Blocks semantic slice |
+| Package logic leaks into core | Library names in ModuleIR/codegen/runtime | Move decision to adapter boundary | Blocks review |
+| ResourceIR added prematurely | Private handles described as shared resources | Reuse EffectIR and closure ownership | Blocks resource item |
+| Component runtime emerges | Browser needs component identity/function calls | Preserve build-time specialization | Blocks release |
+| Pass count hidden | Logic moved into source compiler without deletion | Count semantic decisions and LOC, not filenames only | Blocks complexity gate |
+| Benchmark parity drifts | Different routes/content/a11y | Checked scenario contracts | Invalidates results |
+| Benchmark harness disappears | Ignored/untracked scripts or moving branches | Pin public revision and tracked commands | Blocks proof gate |
+| Chrome tests silently skip | Browser unavailable without required flag | Use `KUDZU_REQUIRE_CHROME=1` | Blocks release candidate |
+| Build scaling shifts to browser | Less static output or more client data | Compare complete HTML and browser bytes | Blocks release |
+| AI benchmark is gamed | Kudzu-specific prompts/private knowledge | Equal public docs, tools, budgets, and raw failures | Blocks 1.0 claim |
+
+## Documentation Update Matrix
+
+| Change | Required documents |
+|---|---|
+| Active work status | `0.9-semantic-compression.md`, this plan |
+| Compiler owner moves | `compiler-current-architecture.md` |
+| Performance result | `PERFORMANCE.md`, active work evidence |
+| Supported migration syntax | `MIGRATION_ROADMAP.md`, README/framework docs as applicable |
+| Deliberate unsupported boundary | `MIGRATION_ROADMAP.md`, fixture README if present |
+| Version plan changes | `versioning.md` |
+| Actual release | `package.json`, lockfile, `RELEASES.md`, README, generator range, release page |
+| Benchmark comparator update | `PERFORMANCE.md`, benchmark revision/lock record |
+
+## Release Candidate Procedure
+
+### RC Preparation
+
+1. Freeze semantic scope.
+2. Complete 0.9.0-06 complexity report.
+3. Pin all benchmark revisions and framework lockfiles.
+4. Build the full fixture corpus from a clean checkout.
+5. Run Node and required Chrome suites.
+6. Run package smoke installation.
+7. Run all maintained Kudzu benchmarks.
+8. Run the final cross-framework matrix.
+9. Publish raw data and failures.
+10. Review every material delta.
+
+### RC Acceptance
+
+The candidate must satisfy:
+
+- all semantic queue items complete or evidence-closed;
+- no unreviewed semantic primitive;
+- no generic browser runtime;
+- core pass/LOC budget passes or has approved bounded exception;
+- static-route zero JavaScript passes;
+- complete initial HTML passes;
+- capability proportionality passes;
+- cross-framework browser/build proof passes;
+- content and stateful application journeys pass;
+- disabled/delayed/missing-JS matrix passes;
+- package and registry process passes on the exact candidate commit.
+
+### Final Release Updates
+
+Only after RC acceptance:
+
+1. Set `@kudzujs/core` to `0.9.0`.
+2. Update lockfile metadata.
+3. Update `create-kudzu` to a `^0.9.0` core range and verify generated projects.
+4. Add factual `0.9.0` release notes.
+5. Update README status and benchmark summary.
+6. Update current architecture version references.
+7. Run `npm run check`, `npm test`, required Chrome tests, and package smoke again.
+8. Pack and inspect package contents.
+9. Publish from the reviewed commit.
+10. Verify npm registry metadata and a fresh generated application.
+11. Create the release tag/page without changing the published artifact.
+
+## Handoff Toward 1.0.0
+
+`0.9.0` proves browser and build advantage. `1.0.0` additionally proves Kudzu is the best framework for AI-assisted delivery under equal conditions and freezes Semantic IR v1.
+
+0.9 work must leave the evidence needed for later AI evaluation:
+
+- stable fixture provenance;
+- deterministic diagnostics;
+- exact acceptance journeys;
+- machine-readable artifacts where already available;
+- compiler attempt/build timing records;
+- source-retention comparisons;
+- no private migration knowledge required to succeed.
+
+### Planned Version Relationship
+
+| Version | Primary outcome |
+|---|---|
+| 0.9 | Semantic compression plus proven cross-framework browser/build advantage |
+| 0.10 | First-class deterministic `kudzu normalize` |
+| 0.11 | Structured diagnostics, explain, fix, and migration analysis |
+| 0.12 | Broader ecosystem adapters through package-neutral semantics |
+| 1.0 | Stable Semantic IR v1 plus best equal-condition AI delivery results |
+
+### 1.0 AI Delivery Protocol Seed
+
+The final 1.0 protocol will use the same:
+
+- model and model version;
+- system constraints;
+- tools and permissions;
+- hardware and network;
+- context and time budget;
+- task statement;
+- starting repository quality;
+- public documentation access;
+- behavior, accessibility, build, browser, and output acceptance suite.
+
+It will include at least content, forms, CRUD/shared state, commerce-derived state, and resource/realtime tasks. Each framework receives at least five attempts per task, with more attempts when results are unstable.
+
+The primary AI metric is cost per successful task. A task counts only when all acceptance checks pass.
+
+Required 1.0 metrics:
+
+- success rate;
+- input, output, and reasoning tokens;
+- monetary cost;
+- elapsed completion time;
+- files read and modified;
+- tool calls;
+- compiler/build attempts;
+- failed attempts and correction cycles;
+- source retention and maintainability review;
+- final browser bytes and performance;
+- diagnostic interactions required;
+- context surface area per successful task.
+
+Kudzu must achieve the highest or statistically tied-highest success rate and the lowest median cost per successful task while retaining the complete 0.9 browser advantage. Build-only completion, cherry-picked attempts, hidden compiler knowledge, or toy-only tasks cannot authorize 1.0.
+
+## Active Status Ledger
+
+| Work item | Status | Next exact action | Blocker |
+|---|---|---|---|
+| 0.9.0-01 | Complete | Baseline, harness restoration, contracts, and explicit gaps are signed off | None |
+| 0.9.0-02 | Complete | Derived closure recorded for Medusa and Mercury | None |
+| 0.9.0-03 | Complete | Shared-state/action closure recorded for Context and Zustand | None |
+| 0.9.0-04 | Complete | Existing EffectIR sufficiency and zero qualifying ResourceIR fixtures recorded | None |
+| 0.9.0-05 | Complete | WorkLedger object-property binding/effect/list ownership and negatives recorded | None |
+| 0.9.0-06 | Complete | Candidate ledger, two deletions, diagnostic audit, and architecture review are signed off | None |
+| 0.9.0-07 | Complete | Final cross-framework browser, ownership, resilience, and build proof signed off | None |
+
+## Immediate Next Session
+
+`0.9.0-01` through `0.9.0-07` are complete. Native C1, the five-target runtime/capability matrices, C2 browser latency, C5 resource ownership, and 10,000-route commerce build time and peak RSS pass. The next milestone is the separately gated 1.0 AI delivery protocol.
+
+The completed final session:
+
+- profiled retained route-plan, artifact-report, and HTML memory at 10,000 routes;
+- reduced peak retention without dropping `.kudzu` evidence or incremental correctness;
+- reran seven rotating 10,000-product samples after the retained optimization;
+- keep the pinned AI migration task runner in the 1.0 work item.