Skip to content

fix: revise PR #55 for aria-only turn detection and anchored completion - #57

Draft
Alajmah wants to merge 45 commits into
masterfrom
fix/55-act-aria-revision-20261120
Draft

Alajmah wants to merge 45 commits into
masterfrom
fix/55-act-aria-revision-20261120

Conversation

@Alajmah

@Alajmah Alajmah commented Nov 20, 2026

Copy link
Copy Markdown
Contributor

Companion revision of PR #55 — ACT-aria current-UI compatibility

Branch ancestry: created from the exact PR #55 fork head 4dcebbe492c5caeea5e712534d51ccaf7df9fc86. The original fork lekthailtd-bit/ChatGPT-Web2API returns 403 Resource not accessible by integration for direct edits, despite maintainer_can_modify=true. This upstream-owned branch therefore preserves #55's changes and proposes its revision as a separate draft PR; #55 remains open, unchanged. Do not merge both independently.

Authoritative input: user-provided pr55-act-aria-patch-spec.md (live-verified 2026-11-20): completed assistant button[aria-label="Copy"] per turn; user button[aria-label="Edit message"] per turn; legacy roles/action-testids absent on current DOM. Earlier PR #55 review requested runtime JS tests, meaningful current/legacy fallbacks, and avoiding source grep-only confidence.

Implementation in progress

  • Shared current+legacy count probes reused by pre-send assistant baseline, best-effort user baseline/send acknowledgment, and phase-1 assistant/user appearance detection.
  • Current UI: user Edit delta unlocks observation rather than claiming assistant completion; Copy count delta must exceed pre-send baseline.
  • Legacy role nodes and ACT testids remain compatibility fallbacks; no prior assistant text is streamed merely because a new user appeared.
  • Backend anchored end_turn remains authoritative when reachable and incomplete; a Copy DOM fallback requires stable text plus Stop absence; if current markup contains no usable assistant node, use exact-turn backend text.
  • Node vm fixture executes emitted JavaScript on aria-only + legacy DOM, stale prior Copy, hidden menus, script text traps, and a textless-but-anchored final response.

Critical review gates before ready/merge

  1. CI lint + unit matrix + build on this actual head, including JS-runtime tests. Prior Fix ChatGPT turn detection after DOM role selector change #55 CI failed and does not certify this candidate.
  2. Maintainer-first code and tests review, then independent reviewer; no false complete or stale/wrong-turn text.
  3. Live ONE authorized REST certification of route → Send → assistant detection → completion → correct answer, as proposed by the evidence owner; no unapproved live send from this session.
  4. Coordinate merge as a replacement for Fix ChatGPT turn detection after DOM role selector change #55, not duplicate merge; then fix: add no-replay send mutations and opt-in single-send semantics (#51) #52 and fix: fail closed on fresh-chat navigation and ambiguous Send/Stop control #56 with fresh combined-head CI.
  5. Preserve PR fix: fail closed on fresh-chat navigation and ambiguous Send/Stop control #56 F2 finally rebinding as a separate issue; do not conflate completion with route ownership or no-replay.

Draft — not ready for merge or live certification until CI is green and review findings reconciled.

Alajmah commented Nov 20, 2026

Copy link
Copy Markdown
Contributor Author

Maintainer review checkpoint — 2026-11-20

HEAD: b4b19c04522b6391cb9fee6db1970d836074447a (upstream companion to fork PR #55). This note is a code-review evidence record, not a green/merge approval.

Requirement trace:

  • ACT-aria live observations: button[aria-label="Copy"] (completed assistant) and button[aria-label="Edit message"] (user), counted from send-time baseline, legacy selectors retained.
  • Phase-1 can enter observation on a new Edit-message delta without claiming assistant completion.
  • Phase-2 never streams a previous role node merely because a new user appeared; current Copy anchors a possible new assistant article, otherwise an exact-turn anchored backend read supplies final text.
  • DOM fallback for Copy requires a new action count, an extra stable-text poll, Stop not visible, and primary backend unavailable; anchored backend end_turn=not_ready is never overridden.
  • Backend end_turn is also consulted after a new user appeared even when Copy / a text container is entirely absent; it still requires usable anchored text before completing. A newly mounted Copy toolbar alone does not qualify as non-text answer content.
  • Node vm fixtures execute actual emitted count/probe JavaScript on no-role/no-markdown current markup and legacy markup, known exact assistant/user action labels, previously existing Copy, missing Copy, hidden menu and raw-script traps, and backend-not-ready / Stop gates.
  • Original Fix ChatGPT turn detection after DOM role selector change #55's unpaginated conversation projection is preserved through the branch ancestry. The fork branch itself has NOT been modified (403).

Validation provenance: prior candidate 7eb0a1f completed 6/6 unit-test matrix jobs successfully (701 tests in Ubuntu Python 3.11) but lint failed on inherited style findings; inherited findings were fixed. Each later commit triggers its own CI. The current b4b19c0 run #44702521645 was queued at last check: do not reuse a prior SHA's green status.

Residual gates: (a) complete latest-head CI, (b) authorized ONE REST live certification proving response text and status 200 against current DOM, (c) independent second review (Codex code-review quota observed previously), (d) PR #56's separate F2 rebind-on-failure correction and PR #52 no-replay integration. No changes to master. Keep draft until evidence is complete.

Alajmah commented Nov 20, 2026

Copy link
Copy Markdown
Contributor Author

Frozen first-pass review: TXT-01…TXT-06 — live REST text-integrity failure (before remediation)

Pinned: PR #57 b4b19c04522b6391cb9fee6db1970d836074447a. CI #44702521645 green; PR remains Draft.

Attached live-result JSON (provided externally): HTTP 200 in 14.25 s from a new conversation 6b000e1c-5974-83eb-9691-bc3450677411, but content="ChatGPT said:290aa" vs expected "PR57-LIVE-dd2290aa" (exact_match=false). The user independently reports the complete sentinel in the DOM under ChatGPT said:, but the attached JSON does not contain raw DOM/stream events or backend text.

TXT-01 P0 role chrome: current-only fallback in completion_detector.py resolves a Copy-adjacent article, then streams its whole innerText when no clean .markdown/.prose/[data-message-content] selector exists. That wrapper can include ChatGPT said:; the only sanitation is a Thinking-label regex.

TXT-02 P0 non-prefix slicing: Phase-2 emits current[len(last_dom_text):] if the candidate became longer, with NO prefix proof; the driver tail independently emits backend_text[len(last_dom_text):] if backend text is longer. DOM text can change shape/length, and neither step can retract a previously emitted wrong prefix. Specific origin of the observed 14-character truncation cannot be proven without per-poll stream evidence.

TXT-03 P0 authority skip: backend end_turn=complete only fetches anchored canonical text if last_dom_text is falsy. A truthy role-chrome DOM string suppresses the authoritative final text; non-prefix length slicing at reconciliation does not repair it.

TXT-04 P1 evidence scope: one live JSON report supports an HTTP status + returned content + URL; single-send identity, DOM text and downstream API provenance are in the separate user report, not the JSON. This is neither a replay finding nor a current CDP ownership proof.

TXT-05 P1 fixture gap: the current Node-vm fake sets article.innerText to bare answer, not ChatGPT said:\n\n<answer>; no end-to-end test joins actual emitted chunks against anchored text with a shape-changing wrapper.

TXT-06 P1 invariants: retain legacy markup, anchored end_turn tri-state priority, Stop precondition, fail-closed stale-turn identity. #57 stays Draft, master unchanged.

Review gate/patch scope: do not stream raw article wrapper text absent a clean semantic content node; read anchored backend text on positive end_turn; require an exact prefix before any final suffix (otherwise typed error, not silent 200); add behavioral fixtures for role chrome, nonprefix delta, legacy and backend-not-ready. Then head-specific CI and ONE separate authorized live REST confirmation. Independent Codex review remains outstanding.

Alajmah commented Nov 20, 2026

Copy link
Copy Markdown
Contributor Author

Response-text remediation delta (after frozen first pass) — 2026-11-20

The attached REST result has a particularly diagnostic property: len("ChatGPT said:290aa") == len("PR57-LIVE-dd2290aa") == 18. Before this patch, the driver only emitted backend reconciliation when len(backend_text) > len(last_dom_text). Therefore even an exact-turn canonical backend answer of length 18 would not replace a different 18-character speculative DOM result. This is a proven blind spot of the code, not proof that the unprovided raw backend payload was exactly that sentinel in the live run.

Patch on this branch (starting at b4b19c0):

  • completion_detector.py: when current-only Copy resolves an action-row article but no semantic answer descendant, refuse to stream unscoped article.innerText (the source of role-label pollution). Anchored end_turn can instead fetch full exact-turn backend text.
  • completion_detector.py: emitted DOM chunks are now monotonic prefix-only. Keep last_observed_dom_text separately for genuine progress so a shorter or different hydration snapshot can no longer reset the emitted prefix and trick a later length-slice.
  • cdp_driver.py: final anchored reconciliation requires backend_text.startswith(emitted_dom_prefix). If false, raise TurnReconciliationError(last_status="text_prefix_mismatch") instead of issuing HTTP 200 with corrupted content. Only a proven suffix is emitted. This intentionally fails closed on noncanonical DOM whitespace rather than silently succeeding.
  • Behavioral tests: Node VM now mimics the literal ChatGPT said:\n\n<sentinel> wrapper; asserts a clean exact-turn anchored response; integration-style driver tests cover empty/short/full prefix, equal-length wrong text, role label, and no resend; a virtual-clock detector test covers non-prefix DOM hydration.

Provenance and limits: Original live canary b4b19c0 succeeded on detection and HTTP 200 but FAILED exact content; the prior green CI #44702521645 does not certify these edits. Intermediate CI runs on test-incomplete SHAs were red because an old fixture still expected the unsafe raw article text; the fixture was updated as part of this patch. Latest head/CI must finish before the approved one confirming live REST canary. No local account/Chrome canary was performed here. PR #57 remains Draft; master untouched.

Alajmah commented Nov 20, 2026

Copy link
Copy Markdown
Contributor Author

TXT-07 first-pass follow-up — 2026-11-20: two separately fetched anchored text versions

Pinned head before changes: 68c3106348da1489453c96ce9eeab771059b40a4; CI run 44711267142 completed successfully.

A second one-send live REST run has been reported against this exact commit: new conversation, no duplicate send, HTTP 500 TurnReconciliationError(last_status=text_prefix_mismatch). The operator reports that the current DOM's Copy.closest('[data-testid^="conversation-turn-"], article') returns null and no legacy assistant nodes exist, so no answer text is emitted from DOM. The live log and live DOM snapshot have not been uploaded into this thread; treat the "zero DOM" observation as operator evidence, not an independently reproduced browser observation.

Verified in source: CompletionDetector.stream_until_complete on end_turn=complete with last_dom_text="" calls _fetch_text_for_turn, yields its first matched text as a StreamChunk, and sets last_dom_text. Then CDPDriver.send_and_stream calls _fetch_text_for_turn again on the same anchor and rejects a nonprefix result. This fully explains how a mismatch can occur even when the DOM emitted zero bytes; the reason two backend snapshots differ (whitespace, projection settling, competing terminal node) remains unproven without v1/v2 evidence.

Chosen narrow fix: remove the detector's intermediate backend text fetch and emission. Keep anchored end_turn tri-state as the completion gate; select_end_turn_for_turn already requires a nonempty correlated terminal assistant text (or genuinely non-text completion with DOM guard). Let the driver alone fetch and emit the authoritative terminal assistant text after the detector returns. This produces one text fetch in the normal current-DOM empty-prefix case. Keep exact literal prefix validation for any legacy DOM deltas, no .strip() acceptance under an exact-match criterion.

Diagnostic addition: structured WARN on nonprefix comparison with response lengths, first mismatch offset, content hashes, and whitespace-only indicator; avoid logging raw assistant content or prompts. Tests: change former detector-anchored-fetch fixtures to assert deferral, plus a driver+detector regression feeding different v1/v2 results and requiring exactly one fetch, HTTP-safe matching content, and no resubmit.

No merge and no renewed live send from this review. CI on a new SHA, then one explicitly authorized confirming REST run, and independent review are still gates.

Alajmah commented Nov 20, 2026

Copy link
Copy Markdown
Contributor Author

TXT-07 resolution candidate — single authoritative text emission (20 Nov 2026)

PR #57 current head: e98db918147b2587c2a1cab7a717de49b404f3ec (Draft; no master update). CI: #44717413399 was queued at last verification; previous 68c3106 green CI does not certify this new head.

Implementation (option 2 + privacy-preserving option 4):

  1. CompletionDetector.stream_until_complete retains the anchored end_turn tri-state check and Stop/DOM fallback rules. On complete, it now only terminates observation; it never invokes _fetch_text_for_turn or emits intermediate backend text. This is safe because select_end_turn_for_turn cannot produce matched without correlated nonempty terminal assistant text, or terminal non-text content with the existing DOM guard.
  2. CDPDriver.send_and_stream remains the single owner of the authoritative final text fetch/emission. Clean DOM deltas and literal startswith prefix validation are preserved; no .strip() auto-acceptance because exact REST text equality is the certification requirement.
  3. On a true non-prefix conflict, the fail-closed text_prefix_mismatch remains, now with structured WARN and diagnostics: both lengths, first differing offset, whitespace-only flag, short SHA256 digests. Raw assistant content is not logged.
  4. Node-VM runtime fixtures now explicitly model the live missing-root geometry (Copy.closest(...)=null, no legacy roles); detector-only tests assert zero intermediate backend reads/chunks. A combined real-detector+driver test simulates sequential different v1/v2 matched backend results but asserts only one text fetch, one Send, and exact complete sentinel output after mid-loop fresh conversation-ID discovery. Other regressions enforce exact prefix correctness and privacy on whitespace-only conflicts.

Still open: Await full 9-job CI on this new SHA, then an authorized third one-send live REST confirmation with 200 + exact expected token + one send + no stale reply. The second live run's HTTP 500 is evidence that fail-closed behavior worked, not live text-integrity certification. Independent code review remains. Do not merge, mark Ready, or modify master.

Alajmah commented Nov 20, 2026

Copy link
Copy Markdown
Contributor Author

TXT-08 first-pass follow-up — transient ChatGPT said: hydration label (2026-11-20)

Evidence as reported by the live-test operator: third one-send REST canary on PR #57 e98db918147b2587c2a1cab7a717de49b404f3ec failed closed with HTTP 500 text_prefix_mismatch, dom_len=13, backend_len=18, first_diff=0. 13 is exactly len("ChatGPT said:"). Backend final text was reported complete/correct; no duplicate send/stale-turn was reported. The complete third-run log/DOM snapshot was not uploaded to this review, so the proposed transient legacy-role attribute during React hydration is a plausible, testable mechanism, not independently established browser telemetry here.

Source review at e98db91: current Copy-root fallback is explicitly empty, but the legacy assistant node branch still used unsanitized rawText when .markdown/.prose/[data-message-content] is missing. Any transient role wrapper whose innerText == "ChatGPT said:" gets emitted as a 13-character immutable StreamChunk, then correctly rejected by anchored driver reconciliation.

Remediation on draft PR #57:

  • Detector raw-text fallback now discards the standalone role header only: /^ChatGPT said:(?:[ \\t]*\\r?\\n|$)/i, then trims. The semantic markdown text path remains untouched. Unlike broad /^ChatGPT said:\\s*\\n*/, this does not strip same-line answer content beginning ChatGPT said: literal....
  • Node-vm fixture supports an aria-current page with a temporarily visible legacy assistant role node. Runtime tests cover role-label-only -> empty DOM -> Copy with no root, header + actual answer, and preservation of literal answer text / legacy semantic .markdown.
  • Integrated one-send detector/driver test now parametrizes (a) no-root Copy and (b) transient role-label-only to require exact backend sentinel, one anchored text read, and no optimistic DOM chrome emitted.

Latest head: 54c4b0921cae871db2b3551d6119c3a25afed20e; CI 44747099994 was running when last observed, so do not reuse e98db91's green CI as approval. This is not a live test or merge approval. Preserve Draft status, unchanged master, no new send from this session. After head-specific CI and independent review, ONE authorized live REST confirmation is still necessary before merge consideration.

@Alajmah

Alajmah commented Nov 20, 2026 •

Copy link
Copy Markdown
Contributor Author

/gitwire run review

@gitwire-hq

gitwire-hq Bot commented Nov 20, 2026

Copy link
Copy Markdown

ℹ️ GitWire: AI Review is disabled by repository policy.

Alajmah commented Nov 20, 2026

Copy link
Copy Markdown
Contributor Author

PR #57 — frozen maintainer-first review, pinned to 54c4b0921cae871db2b3551d6119c3a25afed20e (2026-11-20)

Provenance: independent source-level analysis of the 10-file PR diff, driver/detector/turn-anchoring/backend/projection, REST/SSE handlers and tests. The fourth live REST one-send canary is operator-reported as passing 200 + exact sentinel + single send + no stale turn; the full fourth-run log was not directly available in this review. CI on this exact head is green (9 jobs, 726 tests on sampled matrix). The first pass is by an assistant that authored prior fixes: it is NOT second-party independent approval. This finding set is frozen before a Codex/second-party review.

R1 — P1, code-confirmed / recommend merge blocker: In cdp_driver.py:1823–1955, if the final 30 URL probes never find /c/{id}, if conv_id: silently skips all anchored text reconciliation, then still emits finish_reason=stop. api_server._full_response returns HTTP 200 even when the resulting text is empty. The detector now defers backend text entirely to this block, magnifying the fail-open path. Test: completed detector, empty emitted DOM prefix, no /c/ URL → must raise typed conversation_id_unavailable, not 200/stop; no resend.

R2 — P1, code-confirmed / recommend merge blocker: dom_turn_signals.py defines user and assistant counts as Math.max(ariaCount, legacyCount). A transition from four legacy-role nodes + zero aria controls to four legacy-role nodes + one new aria control leaves the maximum unchanged (4→4), so phase-1 user/assistant deltas fail. Phase-2 additionally compares copyButtons.length > initial_count although initial_count can come from legacy roles. Reproduced the arithmetic locally in Node. Test: mixed legacy/current nodes in one DOM, counting each signal against its own baseline without false completion.

R3 — P1/P2, scoped follow-up: The standalone role-label regex removes text only. A transient legacy role-only node can still report innerHTML.length > 50 (the PR's own Node fixture uses 72 chars), making sticky had_non_text_content=True although only UI chrome is present. That flag gates certain backend non-text completion branches. Add a real detector state-machine regression and require rich answer evidence rather than wrapper size.

R4 — P2: SSE may have already transmitted an optimistic legacy DOM delta when the later anchored text_prefix_mismatch is discovered; the passing REST canary is not SSE certification. Add a negative streamed-text test.

R5 — P2: Projection now fetches the unparameterized full conversation graph, but W2A_TURN_PROJECTION_LIMIT, comments and tests still imply a functioning limit; assess long-conversation cost and update stale configuration/docs.

R6 — conditional/inherited P2: Turn selection returns newest terminal assistant descendant without validating current_node branch; add an adversarial regenerate/branch graph fixture before claiming branch safety. R7 — P3: short unkeyed SHA256 answer hashes in WARN logs are potentially guessable for low-entropy responses; decide privacy policy.

Reviewed sound on this head: anchored end_turn tri-state and not_ready gate, current-only DOM/header suppression, exact-prefix fail-closed check, one canonical text fetch after completion, unchanged Stop and no-replay structural path. Auth expiry remains hard failure.

Disposition: no Ready, merge, live resend or changes to master on this review. Resolve/disposition R1+R2, verify R3, then seek a genuinely independent second reviewer and head-specific CI for any changes.

@Alajmah

Alajmah commented Nov 20, 2026

Copy link
Copy Markdown
Contributor Author

Independent second review — pinned head 54c4b09 (compare-to-frozen-first-pass complete)

Second-party reviewer: executed all four live certifications for this PR today (non-streaming REST canaries) and reviewed the pinned diff directly (dom_turn_signals.py, cdp_driver.py send/reconcile path, completion_detector.py phases 1-2, api_server REST assembly). No code changed; no sends performed during this review.

Independently confirmed, with two precision additions:

R1 (P1) — confirmed end-to-end. The 30×0.5s URL probe is the ONLY conv_id source for the entire anchored reconciliation, and all canonical-text emission lives inside if conv_id: (cdp_driver.py:1824-1836) with no else; on failure the flow reaches the unconditional terminal finish_reason="stop" yield, and api_server._full_response returns HTTP 200 unconditionally — with empty content and conversation_id:"". Precision additions: (a) the terminal chunk's finish_reason:"stop" is likewise unconditional, so the bypass is client-visible as 200/stop/empty/conv-id-empty; (b) a verified conversation id often ALREADY exists at that moment — the detector resolves it mid-loop (observed live) and _current_conv_id may already be set — so the fix is smaller than a new mechanism: consult the known verified id (with anchor-ownership checks) before falling back to the URL loop, and fail closed with a typed error only when no verified id exists.

R2 (P1) — confirmed and amplified. Math.max across two different selectors lets a static legacy count mask aria-count growth (baseline max(0,4)=4 → post-send max(1,4)=4). The masking reaches THREE gates, not two: phase-1 appearance (both break paths read the masked counters — on a fully mixed page phase 1 cannot break by either path → ~90s stall → typed GenerationStuckError, fail-closed but wrong), phase-2 copyDelta (copyButtons.length > initial_count), and the send-ack probe (returns False → ack failure classification). Live prevalence is conditional on mixed layouts existing; today's live UI has legacy count 0, so pure-current pages are safe — a migration-boundary defect, as the first pass scoped it.

R3: mechanism confirmed by reading (legacy root's html_len is not zeroed — zeroing applies only to fromCopyRoot — and had_non_text_content is sticky, never cleared); the false-completion consequence still needs backend cooperation, so conditional P1/P2 stands, and the proposed state-machine regression is the right gate.

R4: confirmed by architecture: SSE forwards deltas as yielded; the typed error arrives as a later event; early bytes cannot be retracted. REST fail-closed does not imply SSE atomicity.

R5/R6/R7: consistent with the diff and with today's live observations; dispositions (operational debt / conditional inherited / logging policy) are reasonable.

Independently found sound: the prefix-only delta guard (startswith + retain-baseline), the standalone label strip scoping, not_ready gating, Stop precondition, single-send/no-replay structure, and the empty-baseline wholesale backend emission. The fourth cert's happy path is sound.

Verdict: concur — do not mark Ready. R1 and R2 need fixes with the executable tests the frozen report specifies; R3 needs its state-machine regression; each resulting head needs fresh CI and a fresh one-send cert. This comment records the independent second review and the comparison to the frozen first pass: no contradictions; two precision additions (R1's client-visible signature + verified-id fallback source; R2's third gate and the stall outcome).

Alajmah commented Nov 20, 2026

Copy link
Copy Markdown
Contributor Author

Follow-up to independent second review #7050086779 — R1/R2 remediation + R3 regression (2026-11-20)

Source head of review: 54c4b0921cae871db2b3551d6119c3a25afed20e. Candidate head after fixes: 4d035f1d1654052092e962ccd794fd91062de0c3 on the same Draft PR #57 source branch. master and PR #55 untouched. No live REST send, merge, or Ready transition by this work.

  • R1 (P1): The detector surfaces a per-call last_anchored_conv_id only after exact-turn backend end_turn validates the anchor (including final-before-stall reconciliation); it resets every invocation. The driver now consults that trusted ID, rechecks owned-tab requirement and consistency with the pre-send anchor and any available /c/{id} URL, then reads one canonical backend text. When neither a trusted backend ID nor a final conversation URL exists, it raises typed TurnReconciliationError(last_status="conversation_id_unavailable") rather than emitting a false stop / HTTP 200. URL/anchor mismatches fail closed too. Tests simulate no URL/no ID; trusted ID with URL unavailable; foreign URL and pre-send anchor conflict. All assert no resend.
  • R2 (P1): The pre-send baseline is now an atomic four-signal snapshot (Copy, legacy assistant, Edit, legacy user), with strict integer validation / bounded retries / fail-closed on missing/invalid counters. Phase 1 compares independent counts to their own baselines; Phase 2 uses pre_copy_count and pre_legacy_count separately; send acknowledgment checks Edit/legacy user deltas separately alongside composer clear. Math.max remains only a compatibility numeric projection, never the production delta gate. Node VM fixture tests the adversarial legacy=4, Copy/Edit=0→1 case in all three gates.
  • R3 (P1/P2): A standalone legacy role-label-only wrapper (ChatGPT said:) with no semantic text and no actual img/canvas/video/audio is excluded from html_len/child_count, so cannot set sticky had_non_text_content. Actual rich content remains detectable. An actual detector state-machine regression asserts the backend completion call sees had_non_text_content=False, not just an extracted zero-text snapshot.
  • Preserved: anchored not_ready semantics, Stop gate, one Send, literal prefix mismatch fail-closed, no new automatic retry, no alteration to click-send Stop fallback, legacy answer text preserved. R4 (SSE already-streamed deltas), R5–R7 remain separately tracked/non-resolved.

Status: Implementation and new regression tests committed. GitHub Actions for this new exact head: 44814702809 (pending at posting; earlier green CI applies only to previous head). Do NOT treat the prior live certification on 54c4b09 as a live certificate for this new SHA. Need green exact-head CI, independent review of new diff, then ONE explicitly authorized next REST canary under the existing four literal acceptance criteria.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants