feat(selfhost): AST producer — unary !/~ + negative number literals → 245/569

- Negative number `-<num>` (exactly two tokens) emits `number -N`, checked before
  binary/closure so it doesn't split as subtraction (matches parse_expr).
- Prefix `!x` desugars to `x == false` (binary equal, right `ident false`); `~x`
  to `Int.bit_not(value: x)`; both after binary split, with paren-stripped operand.

Corpus reach: 242 -> 245 / 569 byte-exact, still 0 run-failures. Floor -> 245.
Diminishing returns confirmed: remaining mismatches are benchmark/selfhost files
that each stack several still-unsupported constructs (interpolation, effect-
receiver calls, fn attributes, protocols/impls). New sample unary.rss; 13 samples
byte-exact.

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

Author: olwang

crates/rsscript/src/selfhost_parity.rs

@@ -1522,7 +1522,7 @@ const AST_SAMPLE_MIN: usize = 6;
 /// Floor for `ast_parity_corpus` — the number of corpus files whose rss AST dump
 /// already matches the oracle byte-for-byte. Ratchets up as the producer's
 /// coverage grows; a drop signals a regression. (Full parity = files.len().)
-const AST_CORPUS_PARITY_FLOOR: usize = 242;
+const AST_CORPUS_PARITY_FLOOR: usize = 245;
 
 /// Step-2 measurement gate (ignored by default): how many corpus files the rss
 /// producer reproduces byte-for-byte. Not full parity yet — this ratchets a floor

selfhost/astdump.rss

@@ -234,6 +234,12 @@ fn emit_expr(toks: read List<Tok>, start: read Int, end: read Int, d: read Int)
         emit(depth: read d, s: read "unknown-expr")
         return Unit
     }
+    // Negative number literal: `-` <number> exactly (before binary/closure, as in
+    // parse_expr) so it doesn't split as subtraction.
+    if e - s == 2 && at_symbol(toks: read toks, i: read s, code: read SYM_MINUS) && tk_kind(toks: read toks, i: read (s + 1)) == TOK_NUMBER {
+        emit(depth: read d, s: read String.concat(left: read "number -", right: read escape(s: read tk_text(toks: read toks, i: read (s + 1)))))
+        return Unit
+    }
     // Closure `|params| body` — checked before binary split so its `|` pipes are
     // not read as bit-or (matches parse_expr's ordering).
     if at_symbol(toks: read toks, i: read s, code: read SYM_PIPE) {
@@ -250,6 +256,20 @@ fn emit_expr(toks: read List<Tok>, start: read Int, end: read Int, d: read Int)
         emit_expr(toks: read toks, start: read (opIdx + w), end: read e, d: read (d + 1))
         return Unit
     }
+    // Prefix `!x` desugars to `x == false`; `~x` to `Int.bit_not(value: x)`.
+    if at_symbol(toks: read toks, i: read s, code: read SYM_BANG) {
+        emit(depth: read d, s: read "binary op=equal")
+        emit_unary_operand(toks: read toks, start: read (s + 1), end: read e, d: read (d + 1))
+        emit(depth: read (d + 1), s: read "ident false")
+        return Unit
+    }
+    if at_symbol(toks: read toks, i: read s, code: read SYM_TILDE) {
+        emit(depth: read d, s: read "call")
+        emit(depth: read (d + 1), s: read "callee-qualified namespace=Int name=bit_not")
+        emit(depth: read (d + 1), s: read "arg name=value")
+        emit_unary_operand(toks: read toks, start: read (s + 1), end: read e, d: read (d + 2))
+        return Unit
+    }
     // Trailing top-level `?` => try.
     if at_symbol(toks: read toks, i: read (e - 1), code: read SYM_QUESTION) {
         emit(depth: read d, s: read "try")
@@ -315,6 +335,19 @@ fn emit_closure(toks: read List<Tok>, start: read Int, end: read Int, d: read In
     return Unit
 }
 
+// A unary operand [start, end): strip parens wrapping the whole operand (matches
+// unary_operand_range), then emit the expression.
+fn emit_unary_operand(toks: read List<Tok>, start: read Int, end: read Int, d: read Int) -> Unit {
+    let mut s = start
+    let mut e = end
+    if s < e && at_symbol(toks: read toks, i: read s, code: read SYM_LPAREN) {
+        let close = find_matching(toks: read toks, open: read s, openSym: read SYM_LPAREN, closeSym: read SYM_RPAREN)
+        if close == e - 1 { s = s + 1; e = close }
+    }
+    emit_expr(toks: read toks, start: read s, end: read e, d: read d)
+    return Unit
+}
+
 // "read"/"mut"/"take" if token i is that effect keyword, else "".
 fn effect_kw(toks: read List<Tok>, i: read Int) -> String {
     if is_kw_text(toks: read toks, i: read i, word: read "read") { return "read" }

selfhost/samples/ast/unary.rss

@@ -0,0 +1,7 @@
+fn checks(a: read Int, done: read Bool) -> Int {
+    let neg = -5
+    if !done {
+        return neg
+    }
+    return ~a
+}