mirror of
https://github.com/stablyai/orca.git
synced 2026-09-22 16:02:32 +00:00
Jinwoo Hong
f24f38bd41
* test(mobile): record the golden corpus through the page bridge (OTA phase C, C0.5) `ScriptedRpcTransport` gains one seam: an optional `wrapClient`, applied between the recorder's own instrumentation and the logical client, so a recording can be driven through another transport without the runner learning which one. `runRecording` passes it through. The instrumentation moves outside the seam. `ordinal` orders a logical `sendRequest` against the recording's device writes and physical payloads, and the operation makes that call at the same moment with or without a wrapper; stamping it under one times the wrapper's forwarded send instead, which the unwrapped recording has no counterpart for. Measured: 131 goldens move their sender ordinal under the seam, none above it. The name a physical send is filed by therefore becomes a queue rather than one slot, taken on the inside of the wrapper — a wrapper that forwards on a microtask arrives after the next logical call has been made, and one slot hands both sends the second name. Underflow throws; a wrapper that drops a send is a finding. `rpc-recording-through-bridge.test.ts` is the harness: every golden recorded again with `BridgeRpcClient` over an in-memory port pair to a `createBridgeHost` holding the scripted client, compared body for body against the committed file. One FIFO per direction, delivery on a microtask, and the `init` handshake delivered in place before anything mounts. It is opt-in behind `RPC_FOUNDATION_BRIDGE=1` and does not pass yet. 391 of 787 goldens diverge, for four causes that are findings about the bridge rather than about the corpus; the suite's header names each one with its count, and flipping the gate is one line once they close. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * chore(mobile): repin the recording corpus and refresh its headers (OTA phase C, C0.5) The C0.5 seam edits `scripted-rpc-transport.ts` and `run-recording.ts`, both inside `RECORDER_DIRECTORY`, so `recorderSha256` moves and every golden's header names an engine that no longer exists. `baseline` moves with it, from1e3795de99toddbb194585, which is main's tip and the tree these were recorded against; the recorder's fence is clean at that commit, tracked and untracked alike. Recorded whole rather than in part, as the README requires: a partial refresh would leave the corpus pinned to two different trees. The delta is header-only, and that is checked rather than asserted. All 787 goldens changed exactly two lines each, and across the corpus and the manifest the only keys that moved are `baseline` and `recorderSha256`, to one value each. No observation moved, which is the claim the pair of digests exists to make: the engine changed, what it observes did not. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * test(mobile): correct the bridged-parity counts to what the landed tree measures The counts in the harness's header were read off an intermediate run: 391 is the divergence with the reply schema's `_meta` requirement already widened, not the divergence this tree has. Against the tree as it lands, 763 of 787 goldens diverge and 24 replay byte-identically; widening `_meta` is worth 372 of them and takes the count to 391. The same intermediate run is behind a wrong sentence in this lane's first commit message, which says no sender ordinal moves with the instrumentation above the seam. Seven do, plus six payload ordinals, and they are the subscribe reorder cause 3 now names. 131 was the count below the seam. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * test(mobile): repartition the bridged-parity classes from a measured run The header's last two counts were read off an intermediate measurement. Classified from the failure text of a run with the `_meta` arms widened, the 391 that remain partition 345 / 33 / 13, not 340 / 13, and the ordinal class is not a reorder on the wire: the page posts its frames in call order and they publish in that order, while the writes the operation makes above the bridge land a delivery earlier. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * test(mobile): let the shared bridge port pair carry any shell client The golden recorder needs the pair the bridge tests already have, holding its own scripted client rather than the fake, delivering the handshake in place so a screen can mount in the same turn, and able to answer one counterfactual: what the page would have done had the shell posted a field it does not. Every other test keeps the shape it had under `createFakeBridgePortPair`. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * fix(mobile): catch a wrapper that swallows a send instead of mislabelling the next The seam took the next name off the queue without checking it belonged to the method now on the wire, so a wrapper that rejected without forwarding left its name behind and the following payload was filed under it. Underflow already threw; this is the other half, and it is the half that is silent. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * test(mobile): pin the bridged-parity partition by rule instead of by reading it Counting the classes by eye is how two of them drifted. Every diverging golden is now named by a rule over the frames and the scenario, each name is disjoint, and a golden that fits none of them fails the run. The first class needs a second replay with `_meta` supplied, because nearly every golden is refused some reply for that field and only supplying it says which ones the field explains: 372 / 338 / 7 / 33 / 13 over 787, with 24 byte-identical. CI runs it so the counts cannot drift again. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * chore(mobile): repin the recording corpus and refresh its headers The seam's name check and the export the parity suite reads both sit inside `recorderSha256`, and the port pair the suite now borrows sits inside the recorder's fence, so the pin moves to this branch's tip and all 787 headers follow. Two lines per golden, both of them header: baseline and recorderSha256, and no body byte anywhere. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * fix(mobile): keep the recorder's own boundary ratchets green Two of them were red, and the first has been since the seam landed, because that commit was checked against the recorder's directory instead of the whole mobile suite. The engine may not import a suite, so the parity classifier moves beside the recorder rather than inside it, where the golden digest would also stop claiming a recording's provenance for a rule that only reads failures. And the raw-port ceiling for the scripted transport rises from five to seven: the seam needs one layer between the operation's call and the logical client, and its two references are what that layer costs. A named argument type takes back the third. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * chore(mobile): repin the corpus onto the ratchet fixes and refresh its headers Supersedes the refresh two commits back: the scripted transport moved again, so both the digest and the pin do. Two lines per golden, both header, no body byte anywhere. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb * fix(mobile): stamp the counterfactual on replies only, not on events An `event` frame carries a `payload` too, so keying off the key rather than the type put `_meta` into subscription bytes. The page reads an event payload as `z.unknown()`, so nothing refused it and the classes did not move, but the tool that names a divergence must not author one. Claude-Session: https://claude.ai/code/session_01JNnE9qzUZMMnqpZWCqM3nb