docs(selfhost): record AST-parity progress 121→245/569 (SH-025, plan)

Update the ledger SH-025 entry and the plan doc to reflect this session's AST
producer coverage: match, generic-qualified calls, closures, for-loops, object/map
literals, unary/negative — corpus reach roughly doubled (121→245 byte-exact, 0
run-failures) via ratcheted milestones. Refresh the covered/residual lists.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: olwang

docs/ledgers/rss-selfhost-ledger.md

@@ -868,33 +868,41 @@ gap is VM value-representation / intrinsic-dispatch cost (the next big lever).
   across all backends; RS0037 removed as a restriction and repurposed for arity;
   spec §20.1 amended.
 
-### SH-025 — AST-dump parity: streaming rss producer at 121/563, residual grammar is the growing tail
+### SH-025 — AST-dump parity: streaming rss producer at 245/569, residual grammar is the growing tail
 
 - **Context:** step 2 of frontend object parity (after the AST-dump format +
   oracle keystone, SH-adjacent). `selfhost/astdump.rss` is a recursive-descent
   rss parser that STREAMS the canonical dump (`selfhost/AST_FORMAT.md`); the
   harness (`crate::selfhost_parity`) diffs it byte-for-byte against the Rust
   oracle over `parse_source_raw`.
-- **Reach:** 121 / 563 corpus files byte-exact, **0 run-failures** — the producer
+- **Reach:** 245 / 569 corpus files byte-exact, **0 run-failures** — the producer
   never crashes; unsupported constructs mismatch (partial/`unknown-*` markers)
-  rather than panic. Curated `samples/ast/*.rss` (6 files: functions, effects,
-  control flow, calls, structs+generics+derives+handle fields, sums, module/use/
-  const/type-alias) are byte-exact and gate non-ignored; `ast_parity_corpus`
-  (`#[ignore]`) ratchets the floor (currently 121).
+  rather than panic. 13 curated `samples/ast/*.rss` are byte-exact and gate
+  non-ignored; `ast_parity_corpus` (`#[ignore]`) ratchets the floor (currently 245;
+  run in `--release`, ~100s).
 - **Covered:** top-level fns (pub/async/native, generic params + bounds, params
   with read/mut/take effects, generic-arg types, return type, body); struct/class/
   resource (opaque, generics, derives, handle/weak fields, defaults, drop); sum
   (variants + fields); const/type-alias/module/use; statements return/let/local/
-  assign/if-else/while-loop/break/continue/expr; a split-at-last-top-level-operator
-  expression parser matching the oracle's precedence, plus call (name/qualified/
-  receiver, named + effect args), field/index, array, try `?`, parens, literals.
-- **Residual (the tail):** for-loops, match statements/expressions, closures,
-  object/map literals, interpolated strings, `!`/`~` unary desugars, negative
-  number literals, effect-receiver calls (`read x.m()`), fn attributes
-  (`#deprecated`/`#lower_name`), effect/retains clauses, protocols/impls/
-  native-modules (they dump in a separate program section, not source order, so
-  streaming can't place them), and `statement_end` operator/postfix line
-  continuation. Each is additive; the floor ratchets as they land.
+  assign/if-else/while-loop/**for**/**match**/break/continue/expr; a
+  split-at-last-top-level-operator expression parser matching the oracle's
+  precedence (with generic-`<>` detection so `Deque<Int>.new()` isn't read as a
+  comparison), plus call (name/**qualified with generic args**/receiver, named +
+  effect args), field/index, array, **object/map literals**, **closures** `|x| …`,
+  **match expressions**, **`!`/`~` unary desugars**, **negative numbers**, try `?`,
+  parens, literals. Patterns: variant/binding/wildcard/literal/struct (fields with
+  shorthand/`_`/effect/nested, `..` rest).
+- **Milestones (this session, each a commit + ratcheted floor):** base fns 58 →
+  decls 121 → match 178 → generic calls 225 → closures 239 → for+literals 242 →
+  unary/negative 245.
+- **Residual (the tail):** interpolated strings, effect-receiver calls
+  (`read x.m()` → ReceiverCall), the explicit-`fn(...)` closure form (captures /
+  declared effects), fn attributes (`#deprecated`/`#lower_name`), effect/retains
+  clauses, tuple/list patterns, protocols/impls/native-modules (they dump in a
+  separate program section, not source order, so streaming can't place them), and
+  `statement_end` operator/postfix line continuation. Remaining mismatched files
+  typically stack several of these at once (diminishing per-feature ROI). Each is
+  additive; the floor ratchets as they land.
 - **Status:** open (growing tail). The producer + parity gate + risk mitigations
   (curated fast gate; module-story decision recorded in AST_FORMAT.md) are in
   place; full 556-file byte parity is incremental, tracked by the ratcheting

docs/self-hosting-stress-test-plan.md

@@ -280,18 +280,25 @@ likely want a sampled fast inner-loop gate plus the full corpus pre-push.
 recursive-descent rss parser that STREAMS the canonical dump (no handle-based AST is
 materialized). Parity harness: `ast_parity_tiny_sample` + `ast_parity_samples`
 (non-ignored, byte-exact vs the oracle over curated `samples/ast/*`) and
-`ast_parity_corpus` (`#[ignore]`, ratchets a floor over all 563 files and asserts
+`ast_parity_corpus` (`#[ignore]`, ratchets a floor over all files and asserts
 **0 run-failures** so a producer crash regresses the gate even if the byte-exact
-count still clears the floor). That corpus gate runs the reg-VM over ~560 files and
-is slow in a debug build — run it in `--release` for a quick measurement; the fast
-non-ignored inner-loop gate is `ast_parity_samples`. Current reach: **121/563
-byte-exact, 0 run-failures** (the producer never crashes; unsupported constructs
-mismatch rather than panic). Covered: fns (generics/effects/
-return/body), struct/class/resource (opaque/generics/derives/handle-weak/defaults/
-drop), sum, const/type-alias/module/use, the core statements, and a precedence-exact
-expression parser (calls, field/index, array, try, effects, literals). Both risks are
-handled: the curated set is the fast inner-loop gate; the module story is decided in
-`selfhost/AST_FORMAT.md` (commit to concatenation). The residual grammar (for/match/
-closures/object-map/interp/unary-desugars/effect-receiver/attributes/protocols/
-line-continuation) is the additive tail, tracked as **SH-025** and gated by the
-ratcheting floor.
+count still clears the floor). That corpus gate runs the reg-VM over ~570 files and
+is slow in a debug build — run it in `--release` for a quick measurement (~100s);
+the fast non-ignored inner-loop gate is `ast_parity_samples`. Current reach:
+**245/569 byte-exact, 0 run-failures** (the producer never crashes; unsupported
+constructs mismatch rather than panic), roughly doubled this session via ratcheted
+milestones: base fns 58 → declarations 121 → match 178 → generic calls 225 →
+closures 239 → for/literals 242 → unary/negative 245. Covered: fns (generics/
+effects/return/body), struct/class/resource (opaque/generics/derives/handle-weak/
+defaults/drop), sum, const/type-alias/module/use, statements (return/let/assign/
+if-else/while/**for**/**match**/break/continue/expr), and a precedence-exact
+expression parser with generic-`<>` disambiguation (calls incl. **generic-qualified**,
+field/index, array, **object/map literals**, **closures**, **match-expr**, **unary
+`!`/`~`**, **negative numbers**, try, effects, literals) plus variant/binding/
+wildcard/literal/struct patterns. Both risks are handled: the curated set is the
+fast inner-loop gate; the module story is decided in `selfhost/AST_FORMAT.md`
+(commit to concatenation). The residual grammar (interpolation, effect-receiver
+calls, explicit-`fn` closures, attributes, effect/retains clauses, tuple/list
+patterns, protocols/impls/native-modules, line-continuation) is the additive tail —
+mismatched files now typically stack several at once — tracked as **SH-025** and
+gated by the ratcheting floor.