feat(desktop): desktop app - #5998
Merged
Merged
Conversation
Resolved by taking staging's copilot refactor (mv/mkdir/cp consolidation, sim_key chips, CredentialLinkDisplay extraction, streaming-arg titles) and re-grafting the desktop-only additions on top: desktopLocalFilesystem + browserCapable payload params, local-filesystem tool schemas, local_*/browser_* tool display titles, and the folder_access grant chip. Dropped the user-skill (load_user_skill) wiring — staging removed lib/mothership/skills in mothership v0.8. Generated tool catalog/schemas regenerated from the copilot contract with staging's sync script. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
The desktop-release reusable-workflow call requested contents: write, which ci.yml's permission grant (contents: read) rejects — invalidating the whole CI workflow. Desktop is tested locally for now; signed builds remain available manually via desktop-release.yml workflow_dispatch, and desktop e2e via its own workflow_dispatch. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
electron@43.1.1 (published 2026-07-14) is exact-pinned for the desktop shell and blocked by minimumReleaseAge until 2026-07-21. Excluded with a drop-after date, following the vetted-typescript precedent. Verified the rest of the desktop dependency set clears the 7-day gate. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
- build/icon.icns regenerated from public/logo/primary/large.png on the Apple icon grid (824px body, r=185.4, centered on a transparent 1024 canvas), compiled with iconutil - dev runs set the same mark via app.dock.setIcon (static/dock-icon.png) — unpackaged Electron otherwise shows its default atom icon - un-ignore apps/desktop/build: it holds electron-builder INPUTS (icon, entitlements), which the /apps/**/build output rule was swallowing — the icns and entitlements were never actually tracked - revert resetAdHocDarwinSignature fuse: it corrupts the packaged binary signature (app killed at launch on arm64); the local ad-hoc deep-sign flow doesn't need it Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
White rounded tile with the black sim wordmark (from public/logo/b&w/large.png), replacing the purple variant. Same Apple icon grid geometry (824px body, r=185.4, 1024 canvas). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…5763) (#5784) * feat: re-home @sim/security/ssrf + sim SSRF dedup onto dev (clean core) * feat(desktop): re-integrate SSRF guard + hardening onto rewritten dev Re-applies the browser-agent SSRF guard and hardening onto dev's evolved desktop files (dev rewrote session/driver/handoff/index and split out errors.ts/keyboard.ts): - session.ts: agent-partition onBeforeRequest is the SSRF choke point — DNS-resolving check (fail-closed) for document navigations, synchronous literal-IP backstop for subresources. - driver.ts: browser_navigate/browser_open_tab validate via checkAgentUrl for a clean model error; also adopt shared sleep/getErrorMessage and drop the local reimplementations + banner separators. - index.ts: local-only crashReporter (native minidumps, no upload) + CSP fallback wired into the app session. - window.ts: record the crash-dump dir on renderer_gone. - config.ts: drop the local LOCAL_HOSTNAMES set for the shared isLoopbackHostname (also removes the dead bare '::1'). - cdp.ts: per-WebContents callbacks so a background tab's events reach its own driver. - updater.ts: the manual check now surfaces network/manifest failures instead of silently swallowing them. - README: correct the App Sandbox / security-scoped-bookmark note. - electron-mock: webRequest.onBeforeRequest + crashReporter stubs. - api-validation: annotate dev's validated-envelope double-cast; bump the route-count baseline 964→965 for dev's already-merged route (ratchets stay tight; non-Zod and double-cast at baseline). Skipped as moot (dev already did them independently): launcher isVisible removal, decideStartRoute param drop, local-filesystem clear() removal. * chore(desktop): biome format install-local.ts (pre-existing dev lint failure) * refactor: apply audit cleanup (reuse + simplify) - domain-check: drop the redundant isIpLiteral guard (isLoopbackIp already validates and returns false for non-literals). - session.ts: use shared getErrorMessage instead of the local error ternary (the file already imports it). - tray.ts: use shared sleep() instead of a hand-rolled setTimeout promise. - updater.ts: distinguish the synchronous-throw log from the async-rejection log on the manual update check. * refactor: /simplify pass + review fixes - url-guard: bound the SSRF dns.lookup with a 5s deadline (fails closed on timeout) so a slow/hung resolver can't suspend the check and the onBeforeRequest callback indefinitely (Greptile P2); + test. - Finish the reuse consolidation the earlier pass missed: session.ts second error ternary → getErrorMessage; the bracket-strip idiom → unwrapIpv6Brackets in input-validation.ts, input-validation.server.ts (×2), onepassword/utils.ts (fixes the check:utils banned-pattern CI failure). - driver: document why the tool-level checkAgentUrl coexists with the onBeforeRequest enforcement seam (clean model error; loadURL rejection is swallowed). * fix(desktop): swallow late DNS rejection after the SSRF lookup timeout (Cursor)
|
The latest updates on your projects. Learn more about Vercel for GitHub.
|
|
| GitGuardian id | GitGuardian status | Secret | Commit | Filename | |
|---|---|---|---|---|---|
| 35187658 | Triggered | Username Password | 8f45b0c | apps/desktop/src/main/browser-credentials/vault.test.ts | View secret |
🛠 Guidelines to remediate hardcoded secrets
- Understand the implications of revoking this secret by investigating where it is used in your code.
- Replace and store your secret safely. Learn here the best practices.
- Revoke and rotate this secret.
- If possible, rewrite git history. Rewriting git history is not a trivial act. You might completely break other contributing developers' workflow and you risk accidentally deleting legitimate data.
To avoid such incidents in the future consider
- following these best practices for managing and storing secrets including API keys and other credentials
- install secret detection on pre-commit to catch secret before it leaves your machine and ease remediation.
🦉 GitGuardian detects secrets in your source code to help developers and security teams secure the modern development process. You are seeing this because you or someone else with access to this repository has authorized GitGuardian to scan your pull request.
Both sides independently claimed idx 0271, so the snapshot and journal would conflict add/add. Ours is plain additive DDL that drizzle regenerates from schema.ts; staging's is a hand-written CONCURRENTLY index build that cannot be regenerated. Dropping ours and re-generating on top of staging's is the only order that preserves both. schema.ts is deliberately untouched — it is the source of the regeneration. Co-Authored-By: Claude <noreply@anthropic.com>
Resolutions:
- packages/db/migrations — no conflict by construction; the branch's 0271 was
reverted to the merge-base in the preceding commit, so staging's 0271
(a hand-written CONCURRENTLY index build) applied cleanly and the branch's
additive DDL regenerated on top as 0272. Regenerated content is byte-identical
to what it replaced, and drizzle reports no drift.
- workflow-alias-backing.{ts,test.ts} — kept deleted. The branch removed this
subsystem deliberately (ac55b1f); staging kept evolving it. Verified all
three exported symbols have zero references in the merged tree before
resolving, so nothing is left dangling.
- workspace-file-manager.ts — took HEAD for the two alias-module imports, but
KEPT staging's generateRequestId import: staging's new code at the call site
merged in cleanly and uses it, so taking our side wholesale would have
compiled to a missing binding.
- check-api-validation-contracts.ts — the route-count ratchet. Neither side's
number is right: the merge unions both sets, so the baseline is 985, measured
from the merged tree rather than picked from a side.
- bun.lock — regenerated from the merged manifests with the pinned bun (1.3.13)
rather than hand-resolved; --frozen-lockfile verifies clean.
Co-Authored-By: Claude <noreply@anthropic.com>
Both sides independently claimed idx 0272, so the snapshot and journal would conflict add/add. Ours is plain additive DDL (one enum, two columns, one jsonb default) that drizzle regenerates from schema.ts; staging's is a hand-written migration with DO blocks and CONCURRENTLY index builds that cannot be regenerated. Dropping ours and re-generating on top of staging's is the only order that preserves both. schema.ts is deliberately untouched — it is the source of the regeneration. Co-Authored-By: Claude <noreply@anthropic.com>
Conflicts resolved: - workspace-file-folder-manager.ts: staging kept the workflow-alias import while ac55b1f deleted that module here, so only staging's collectDescendantFolderIds import survives — the alias symbol has no remaining callers. - check-api-validation-contracts.ts: route baseline is additive on both sides (979 base + 6 ours + 2 staging); audit reports exactly 987. - bun.lock: regenerated from the merged package.json files rather than hand-merged. Our 0272 was dropped in the preceding commit and regenerated as 0273 on top of staging's 0272; the emitted SQL is byte-identical to what was dropped. Co-Authored-By: Claude <noreply@anthropic.com>
drizzle-kit emits _journal.json and the snapshot with expanded arrays, which biome check rejects. The merge commit used --no-verify, so lint-staged never formatted them and CI's lint step failed on exactly these two files. Whitespace only — both files are byte-identical under `jq -S -c`. Co-Authored-By: Claude <noreply@anthropic.com>
promptForSecret gates Touch ID on process.platform === 'darwin'. The suite mocked electron's systemPreferences but inherited the runner's real platform, so the eight biometric expectations passed on a Mac and failed on Linux CI, where every call fell through to the confirmation dialog instead. Pins the platform per-test and restores it after, and adds a case for the gate itself — the branch whose absence from the suite is what let this through. Co-Authored-By: Claude <noreply@anthropic.com>
# Conflicts: # apps/sim/lib/copilot/vfs/workflow-alias-resolver.ts # bun.lock # scripts/check-api-validation-contracts.ts
github-actions
Bot
added
the
requires-mothership-merge
|
j15z
added a commit
that referenced
this pull request
Jul 29, 2026
CI runs the merge with staging, and staging's desktop PR (#5998) taught `parseSpecialTagData` to recover a failed `<question>` body's prompt and render it as text instead of returning null. That recovery lands before `classifyBody` is ever consulted, so this fixture — whose quoted `</options>` sat inside its `prompt` — stopped exercising the blanking rule and started asserting the recovery. Merged, it rendered "A use </options> here? B" instead of "A B". Moving the quoted marker to a non-`prompt` field restores what the test is for: a marker inside a JSON string must be blanked before the scan, or a broken payload gets classified as literal text and its raw JSON is shown. A body with no recoverable prompt reaches `discard` on both sides of the merge, matching the prompt-less fixture the sibling test above already uses. Behaviour is unchanged on either branch alone; only the fixture moved. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
10 tasks
j15z
added a commit
that referenced
this pull request
Jul 29, 2026
…esolve (#5952) * fix(copilot): render unclosed special tags as text on completed messages The special-tag parser suppressed everything after an opening tag with no close, even after streaming ended — so an assistant message that merely MENTIONED `<workspace_resource>` in prose lost its entire remainder in the UI. The stream itself completed fine; only the render truncated. Suppression now applies only while streaming. A completed message can never finish an unclosed tag, so the marker was literal text and the remainder is rendered as-is. Originally written alongside the docs/ VFS work and reverted at review time to keep that PR to one concern; this restores it on its own. * improvement(copilot): show text as soon as an unclosed tag cannot resolve Restoring the text only at end of stream left a real gap: once the model mentions a tag in prose, everything after it stays invisible for the rest of the stream and reappears in one jump when streaming stops. On a long reply that is most of the message. Two properties let us decide much earlier, both conservative — they only fire on content that could not have parsed: - Tags never nest, so any special-tag marker inside the body (opening OR closing, not just a mismatched close) proves the opener was literal text. - JSON-bodied tags must start with `{` or `[`, so the first non-space character settles it — prose after the marker is caught on the very next chunk rather than at the end. The second is per-tag, not global: `thinking` bodies are prose by design (parseTextTagBody), so the JSON rule cannot apply there and only the nesting rule can rescue it. A test documents that remaining gap rather than leaving it implicit. A false positive is cheap by construction: text shows early and the end-of-stream parse still produces the correct final render. * fix(copilot): ignore tag syntax quoted inside a JSON tag body The nesting rule treated any tag marker in the body as proof the opener was literal text. But a JSON body can legitimately quote tag syntax — a `<question>` asking which tag to use, a `<workspace_resource>` whose title mentions one — and that is exactly the "model explains its own tags" situation this whole fix exists for. Bailing there is the one expensive false positive in the design: the raw JSON renders and STAYS for the rest of the stream, then snaps into a card when the real close arrives. More jarring than the bug being fixed. For JSON-bodied tags the nesting scan now runs over a copy with string literals blanked (escape-aware, and tolerant of the unterminated trailing string that is normal mid-stream). Markers in real body position still count. `thinking` is unaffected — its body is prose, so there are no strings to confuse it. Tests cover both halves: the streaming case does not bail, and the same body resolves to a question card once it closes. * fix(copilot): keep prose a mispaired tag would swallow, and bail on dead JSON Two more real cases from traces, both of which the earlier heuristics missed. 1. A MATCHED pair whose body fails to parse was silently dropped, cursor and all. When the model explains tag syntax and ends with a backticked example containing a real closing tag, that example closes an EARLIER opener and three paragraphs become the "body" — which is not valid JSON, so the whole span vanished and the render resumed mid-sentence (trace b095e080). Now emitted verbatim, but only when the body contains a tag-shaped marker, which is what shows the pairing was wrong. A marker-free body that merely fails validation is a genuinely malformed agent payload and keeps being dropped — an existing test asserts that deliberately, and showing the user raw JSON there would be a regression. 2. The JSON heuristic only checked the FIRST character, so `{"type":"file"}</workspac and then prose...` looked viable forever: it opens with `{`, and the truncated close is not a marker any rule can see (trace afbeefd0). Track depth instead — once the top-level value closes, any non-whitespace after it is fatal, so the stray character decides it immediately. String contents are blanked first so braces inside strings do not skew the count. * fix(copilot): keep prose a tag wrapped instead of a JSON payload Third real case from a trace (1206fd8a): `<workspace_resource>the gmail-agent workflow</workspace_resource>` — a matched pair whose body is plain prose. The sentence rendered as "...once I wired up to handle the welcome sequence" with its subject silently removed. The marker test could not fire (prose contains no tag markers), so it fell to the deliberate drop-malformed-payload path. But that path exists for an agent emitting BROKEN JSON, not for a tag wrapping prose. The distinction is whether the body was ever an attempted payload, which isViableJsonPrefix already answers: `{"type":"single_select"}` is a well-formed JSON value failing its shape guard and keeps being dropped; `the gmail-agent workflow` was never a payload and is emitted. * refactor(copilot): resolve each special tag through four named outcomes parseSpecialTags had grown five inline branches, each added for a specific malformation found in a trace. The shape made "drop it" the implicit fallback, which is how spans that were never malformed payloads ended up silently swallowed. Extracts resolveTagAt, returning one of four named outcomes — segment, literal, discard, pending — so each decision is explicit and the main loop just dispatches on it. Fixes a latent bug the old shape hid: rejecting an unclosed tag ran `break`, abandoning the rest of the message, so a genuinely valid tag after a literal mention was never parsed. Resolution now resumes just past the rejected opener and scanning continues. Test added. Two behavior notes: - Rejected spans are emitted in smaller pieces. The renderer concatenates adjacent text segments into one markdown string, so this is display-neutral; the two tests that asserted exact segment arrays now assert joined text. - Each opener is judged on its own evidence. Previously one verdict ended the whole parse, so a nested opener released everything; now the outer is released immediately and the inner is a fresh candidate that can still hold mid-stream. It resolves at end of stream either way. * test(copilot): pin the no-closing-tag case as lossless Fourth malformation from a trace (220cc02d): the model wrote an opening tag with valid JSON and no closing tag of any kind. No marker rule can fire — there is no marker — but the JSON value completes and prose follows, which the depth rule settles at the first space after the `}`. Already handled by that rule; this pins it. Asserted as lossless rather than merely visible: mid-stream and complete, every character of the message survives, so nothing waits for the stream to end. * fix(copilot): stop the literal path flashing payloads and rescanning the buffer Review round on the four-outcome rewrite. Three defects in how an opener is judged, plus the cost of judging it. A valid tag showed its raw payload as text while its closing marker streamed in. The JSON value closes at the `}`, so a half-arrived `</opt` read as stray trailing content and settled the tag as unresolvable. Every JSON-bodied tag hit this, and most replies carry a trailing <options> block. dropArrivingClose now ignores a trailing fragment that could still grow into this tag's own close. Evidence that a close is genuinely wrong still lands immediately: a misspelled `</workflow_resource>` is not a prefix of `</workspace_resource>`, and a truncated `</workspac` stops being one the moment prose follows it. bodyIsLiteralText scanned the raw body for tag markers while its streaming counterpart blanked JSON string literals first. A payload that failed its shape guard and legitimately quoted tag syntax was therefore called literal text and rendered as raw JSON, which is what discard exists to prevent. Both paths now judge the same blanked body. An opener whose own close was misspelled reached forward and matched the NEXT tag's close, swallowing a valid resource into one literal span and destroying its chip. When markers in the body prove the matched close belongs to a different opener, resolution resumes past the opener so the interior is rescanned and the inner tag still renders. Cost: resuming past a rejected opener instead of abandoning the message made each parse O(openers x length), and the parse re-runs for every streamed chunk. A 40KB reply repeatedly mentioning a tag name cost 7.3s of blocked main thread. The unclosed-body inspection is now bounded, since both rules decide on their first piece of evidence, and the opener and close lookups are memoized per parse rather than rescanning to the end of the buffer for every opener. Same message: 1.2s. A realistic 40KB reply with 8 mentions: 0.35ms per parse, 28ms across the entire stream. Also derives JSON_BODY_TAG_NAMES from SPECIAL_TAG_NAMES so a new tag cannot silently fall back to the weaker prose heuristics; deletes a docstring the rewrite orphaned above TAG_SHAPED_MARKER; corrects one still describing the first-character check that depth tracking replaced; drops a test duplicating one already in the file; and fixes a test that named the no-nesting rule but passed with that rule deleted, because its JSON closed before the marker. * refactor(copilot): drop the JSON-prefix wrapper the split orphaned Splitting isViableJsonPrefixOf out so callers that had already blanked the body would not pay for a second pass left isViableJsonPrefix behind with no callers. Both call sites blank the body for their own marker scan first, so the wrapper has nothing left to do. Biome does not flag it, so it would have sat there indefinitely. The wrapper's docstring carried the actual argument for depth tracking over a first-character check, which is the non-obvious part of the function; it moves onto isViableJsonPrefixOf rather than being deleted with it, along with the already-blanked precondition its callers rely on. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * refactor(copilot): drop the nested-marker scan the JSON rule already covers The unclosed-tag check ran two rules over every JSON body: a scan for nested special-tag markers, then a JSON-viability test. The scan earned nothing there. A marker outside a string literal is stray content the viability rule already rejects, and a marker inside one is legitimate quoted syntax the scan is explicitly blanked to ignore. It cost 14 substring scans per opener per streamed chunk to catch nothing. Verified by deletion rather than by argument: with the scan disabled for JSON-bodied tags, the only failures were the two tests written for the scan itself, and neither is trace-derived. One documents its own contrivance — the array is left unclosed on purpose because a closed value would let the JSON rule decide it. Every test pinned from a real message still passes. The rule stays for the prose-bodied tag, where a body that is not JSON leaves nesting as the only available evidence. The foreign-close test moves to <thinking> to cover it there; the marker-outside-strings test goes, since its premise was the scan. One narrow case regresses: stray non-JSON content inside a still-open structure (`<question>[{...} </options>`) now stays hidden until the stream ends rather than settling mid-stream. Depth tracking counts brackets, it does not validate syntax. Self-healing at end of stream, and buying it back means a real JSON prefix validator — more machinery than the case is worth. Also pins two behaviors that had no coverage and would have been "simplified" away. The two literal reasons resume at different offsets: never-a-payload must resume past the CLOSE, because resuming past the opener rescans an interior whose quoted markers the blanked scan never saw, re-parsing a tag inside a JSON string and dropping it. Collapsing the reasons passes all 54 existing tests and silently deletes text. Escape handling in the string blanker is likewise only observable through depth skew. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(copilot): stop the rescan deleting quoted text, and bound its cost Review found the foreign-markers rescan reintroducing the failure this branch exists to remove. Three fixes, each with a mutation-checked regression test. The rescan decides on the BLANKED body but resumes at the opener and re-scans the RAW one, so a tag quoted inside a JSON string — invisible to the decision — is re-parsed as a real tag on the second pass and dropped. A question whose prompt quotes a <credential> example rendered with the quoted payload deleted. Resolution now resumes at the offset of the marker that actually survived blanking, so the quoted region is skipped and emitted verbatim. Promotion of a quoted tag into a live control is not reachable: quotes inside the outer JSON string must be escaped, so the inner body never survives JSON.parse. That offset is taken from the blanked copy and applied to the raw body, which makes index preservation load-bearing rather than decorative. A blanked astral character emitted one space for two UTF-16 units, shifting every later offset left; it now emits char.length. No test pins this — the drift only moves a text segment boundary, and adjacent text segments concatenate — so the invariant is stated in the docstring instead of guarded by a test that cannot fail. The matched-pair body had no size cap, unlike the unclosed path. A borrowed close stretches one body across most of the message, and the scan reruns for every opener inside it on every streamed chunk. A 58KB reply of that shape — organic, it is trace b095e080's own mechanism — cost 242ms per parse on the main thread, and the parse reruns per chunk. Bounding the scan to MAX_UNCLOSED_BODY_SCAN brings it to 35ms. The bound needed a guard the reviewers' version omitted: when only a prefix was inspected, finding no reason is not evidence the body was a payload, so it resolves to literal rather than discard. Without that, capping converts unexamined bodies into silent deletions — the naive fix would have caused the bug it was meant to prevent. Finally, pushText dropped whitespace-only spans. Harmless when failed tags were dropped whole; the literal path emits a rejected span in pieces, so a blank line between two of them vanished and two markdown paragraphs merged. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * test(copilot): assert what a reader sees, and pin the unclosed-thinking trade Review found several tests asserting only `hasPendingTag`. That boolean can be correct while a wrong resumeAt drops the trailing prose — the exact defect twice fixed on this branch — so those tests could not have caught it. They now assert the rendered text alongside the flag. Adds renderedText(), since a dozen tests hand-rolled the same map/join, and switches two discard tests off exact segment-array equality onto it. How a span splits across adjacent text segments is not observable: the renderer concatenates them. Pinning the array shape only breaks on refactors that change nothing a reader sees, which is what those two did. Adds a frame-replay test. Everything else asserts one end state, so nothing covered behavior BETWEEN streamed frames, where a card could render and then revert. replayFrames() parses every growing prefix and asserts card count never decreases — appending can only add closes after the ones already matched, so no earlier opener's resolution can change. Pins the unclosed-<thinking> behavior as a deliberate trade rather than leaving it incidental: hidden while streaming, shown once the stream ends. Hiding is the right mid-stream default because a close is still plausible and `thinking` renders as nothing anyway. Showing it at the end does leak reasoning when the close never arrives, which is accepted — that is rare, and keeping it hidden would swallow the answer whenever the model opened the tag and then wrote the reply without closing it. Not taken: the reviewer suggestion to swap the prose path's tag-name scan for TAG_SHAPED_MARKER. It matches any `<foo>`, and thinking bodies are prose that legitimately discuss markup, so it would release those bodies early and make the leak above more frequent — the opposite of the default just chosen. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * docs(copilot): name the scan window's blind spot instead of glossing it Bugbot is right that the window can hide a streaming tail, and the docstring said the bound "reaches the same verdict as the full remainder for any real payload" — true for every payload a tag carries, but it read as unconditional and hid the exception. The exception, now stated and pinned by a test: a JSON body whose top-level value closes BEYOND the window, followed by prose and no closing tag, still reads as a viable prefix, so the remainder waits for the stream to end instead of settling mid-stream. Lossless — the completed parse renders every character — and it needs a payload several times larger than any tag emits. A mention in prose settles at its first character at any length, because prose does not open with a brace; the test pins that half too, since it is the case that actually occurs. Not widening the window: the bound is what took a 58KB borrowed-close reply from 242ms to 35ms per parse, on the main thread, re-run every chunk. Trading a measured freeze for a hypothetical one is the wrong direction. The docstring also now covers the matched-pair path, which the same constant bounds since the previous commit. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(copilot): make the indexOf cache correct for any call order The cache was safe only under a precondition the code could not enforce: that `from` never decreases within a parse. Violating it does not throw — a stale index is returned and the parser silently mis-parses, which is the exact failure class this branch exists to remove. Each entry now records the offset it was searched at, and is reused only when the new `from` is at or beyond it. A cached -1 still answers any later `from`, since absence from an earlier offset implies absence from a later one; a cached hit still answers when it lies ahead of `from`. Anything else rescans. The precondition held and still holds — every non-pending outcome resumes strictly past its opener. But it is a property of resolveTagAt's resume points, not of this function, and one of those points deliberately resumes back inside a span it already examined. Someone adjusting a resume point should pay a redundant scan, not corrupt a parse. Verified by mutation: reverting the guard fails the new backward-cursor test and nothing else, so the guard is load-bearing and the monotonic path is unchanged. Same-content benchmark on a 79KB reply: 3.13 ms/frame before, 2.96 after — the entry object is allocated only on a real scan, which is already bounded. memoizedIndexOf is exported for the test. The invariant cannot be provoked through parseSpecialTags, because the cursor does not walk backward today; that is the whole point, so it has to be exercised directly. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(copilot): resume at the window edge, not past the close, on a truncated body Regression from the scan bound added two commits ago. When a borrowed close stretches a body past MAX_UNCLOSED_BODY_SCAN and the inspected prefix is marker-free prose, resolution resumed past the borrowed close — skipping the uninspected remainder entirely. A valid tag sitting in that remainder was flattened to plain text purely because of which side of the window it landed on. Measured: with ~1KB of prose before it the chip rendered, with ~6KB it did not. A verdict drawn from a prefix — "prose", or no verdict at all — says nothing about the rest of the body, so resumption now lands on the first character that was NOT inspected. Everything inspected is still emitted as text by the caller, and scanning continues into the remainder, so the tag renders. Ordering matters: foreign-markers keeps priority, since a marker found inside the window is a real offset and resuming there is strictly earlier and safer. No text was ever lost in this case — it stayed lossless throughout — but a destroyed chip is a real regression, and it was introduced by the fix for the previous one. Cost is bounded: each truncated step advances a full window, so a long body costs body-length/window re-entries rather than one scan per character. A 117KB borrowed body parses in 0.1ms. Verified by mutation: restoring the old resume point fails the new test at 6KB and 60KB and nothing else. The test asserts three lengths so the boundary itself is covered rather than one side of it. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(copilot): only discard a body that actually parsed as JSON `discard` fired on any body parseSpecialTagData rejected, which conflated "is not valid JSON" with "is valid JSON of the wrong shape" — even though its own comment has always said "a well-formed value that failed its shape guard." The viability rule cannot separate them, because bracket depth reads `{the Q4 report}` as a viable JSON value. So prose someone wrapped in braces was deleted: I saved <workspace_resource>{the Q4 report}</workspace_resource> for you. -> I saved for you. along with the two commonest JSON slips a model makes, unquoted keys (`{type: "file"}`) and single quotes (`{'type':'file'}`). All three are text loss of exactly the kind this branch exists to remove. Dropping text is only defensible for a payload the agent actually formed, so discard now requires the body to parse. Anything that will not parse was never demonstrably a payload and is shown instead. A valid payload with the wrong shape still discards, which is the case the outcome was written for, and a valid tag still renders. Costs a second JSON.parse of a body that already failed one. That is the rare path: a valid payload returns before it, and prose is rejected by the cheaper viability rule before it. Verified by mutation: removing the gate fails the new test and nothing else. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(copilot): apply the nesting rule to a prose body on the matched-pair path too A prose body has no shape to fail — parseTextTagBody accepts any non-empty text — so <thinking> was the one tag whose close was accepted unconditionally. The unclosed path already refuses an opener whose body carries a tag marker, on the grounds that tags never nest. The matched-pair path did not, and the two disagreeing is the bug. Mid-stream a nested marker disproves the outer opener, so its text is released and the inner tag renders. When </thinking> finally arrived it was accepted as a segment, and everything already on screen was swallowed into it and suppressed: a <thinking>b <options>[...]</options> c -> "a <thinking>b [CARD] c" a <thinking>b <options>[...]</options> c</thinking> d -> "a d" A rendered card and its surrounding text disappearing from a message the reader was already looking at. Both paths now apply the same rule, and resolution resumes at the opener so the inner tag survives the rescan — safe here because prose bodies are never blanked, so no marker is hidden from the scan the way one can be inside a JSON string. The frame-replay helper counted a thinking body as visible text, which is why its card-monotonicity assertion could not see this. It now models the renderer: thinking contributes nothing. Verified by mutation — removing the rule fails the new test and nothing else. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * test(copilot): assert parser invariants over generated messages Every regression review found on this branch was a combination nobody had written an example for. The example tests cannot cover the space: a body is judged on body kind, close state, JSON state, marker placement, size against the scan window, and streaming mode — a product of roughly six hundred cells, each needing both an outcome and a resume point. Four invariants over messages composed from fragments, so a new combination is covered without a new test: - no character is lost from a message containing nothing droppable - every valid tag renders as a card whatever surrounds it - across streamed frames a card never un-renders and text never retracts - the settled parse never shows less than the last streaming frame Fragments are the shapes the parser must reject — prose mentions, misspelled and truncated closes, brace-wrapped prose, unquoted keys, a nested marker in a prose body, filler long enough to cross the scan window. None is a valid tag or a well-formed payload, so nothing is eligible for discard, which is what makes "output equals input" a legal assertion. Seeded, so a failure reproduces. Validated against the three defects review found, with the fix for each reverted and only these tests running: the flattened tag past the window fails the card invariant, the deleted brace-wrapped prose fails the loss invariant, and the retracted thinking close fails both loss and retraction. They pass on current code, so nothing further is reachable through the shapes they generate. The generator composes several fragments between tags rather than one. With a single fragment it cannot place an unclosed opener and then enough prose to push a valid tag past the scan window, which is exactly the shape of one of the three — the first draft missed it for that reason alone. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(copilot): strip a stray null byte from the test file A space in the visibleView card placeholder was written as U+0000, so the file contained one null byte. Git classifies a file with a null byte as binary and shows "Bin 34936 -> 41628 bytes" instead of a diff, which made the test file unreviewable in the two commits since 2f9b60a. Nothing caught it: vitest, tsc and biome all read the file fine, and the byte sat inside a string literal used only as a placeholder in test-only output, so no assertion depended on it. Only `git diff` noticed. The PR diff renders as text again. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * refactor(copilot): split resolveTagAt into budget, classification, and resume resolveTagAt answered three orthogonal questions in one body of branches — is this a payload, how much of it may I read, and where do I resume — and every regression review found on this parser was one of those answers changing without another. Two of the five were regressions from the fix for the previous one, and the last two were not missed inputs at all: one was the code contradicting its own docstring, the other two branches applying different rules to the same question. That is what coupling looks like, not bad luck. Now three pieces: - inspectWithin — the read budget, and nothing else. Both paths spend it through the same helper; they previously applied the same constant in two shapes, and the difference between those shapes was a bug. - classifyBody — what the body IS. Pure: no positions, no outcome, no resume. Returns one of a closed set of five classes. - resumeForClass — where scanning continues, given the class. Nothing else. The closed set is the point. resolveMatchedPair and resumeForClass each switch over it exhaustively, so adding a class fails to compile until BOTH questions are answered for it. Verified by adding a sixth case: tsc reports exactly two errors, one per switch. The failure mode that produced five review rounds is no longer representable. Behaviour is identical, not merely believed to be. Diffed against the previous implementation over 7,500 comparisons — 1,500 generated messages, each parsed streaming, settled, and at three mid-stream cut points — asserting deep equality of the full result, not just rendered text. The one divergence the differential found was mine: the prose nested-marker path resumed at the marker rather than the opener, emitting one text segment where the old code emitted two. Display- identical, since adjacent text segments concatenate, and arguably better — but a behaviour change does not belong in a refactor, so prose nesting is now its own class that resumes exactly where it used to. The improvement is noted in the type for whoever wants it. The 70 tests, including the four property invariants added on the parent branch, pass unchanged. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(copilot): stop backtick stripping from unbalancing a whole message The display sanitizer removes a backtick sitting next to a workspace-resource tag, so a stray one cannot stop a chip rendering. It could not tell a real tag from prose MENTIONING the tag name, and a mention is the common case: The `<workspace_resource>` tag needs a real `path` to render. -> The <workspace_resource>` tag needs a real `path` to render. The opening backtick goes, the closing one is left unpaired, and it opens a code span that runs to the next backtick — inverting every code span for the rest of the message. A three-paragraph explanation renders with most of its prose in monospace and stray backticks visible in the text. Both unpaired-strip patterns now require the complete opener-payload-closer to be present with no backtick inside it. That is what separates the two cases: a payload is JSON and contains no backticks, while a mention has no closer at all. The one-sided stray backtick around a real tag — the case these patterns exist for — still strips, and the balanced-code-span unwrap above them is untouched. Pre-existing, and not in this branch's two files, but only reachable because of them: until this branch, a prose mention of the tag blanked the rest of the message, so the mangled formatting was never on screen to see. Verified end to end through sanitizer -> parser -> Streamdown: the reported message keeps all 14 backticks and renders 7 balanced code spans with no spurious chip, and a real backticked tag still renders its chip with the wrapping removed. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(copilot): apply the same backtick guard to the balanced unwrap The previous commit fixed the two unpaired-backtick strips but left the balanced unwrap above them, which has the identical flaw. It allows anything between opener and closer, so a message writing the two markers as separately backticked spans reads as ONE wrapped tag and loses its outer pair: Use `<workspace_resource>` then close with `</workspace_resource>` here. -> Use <workspace_resource>` then close with `</workspace_resource> here. Two backticks gone, the remaining two mispaired, same message-wide code-span inversion. This is the shape a message explaining the tag syntax naturally takes, which is how the original report was produced. All three patterns now forbid a backtick between opener and closer. Verified across the matrix: a real tag still unwraps whether the stray backtick is on both sides or one, and every mention shape keeps its backticks balanced. Known and accepted: a resource whose title or path itself contains a backtick will not have wrapping backticks stripped, so it renders as text instead of a chip. That failure costs one chip and is rare; the one it replaces corrupts the formatting of an entire message and is common. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(copilot): pair backticks the way markdown does, and bound the scan Review found my previous two commits traded one bug for a worse one. Three independent reviewers measured it. The trailing-backtick pattern anchored on the bare `<workspace_resource>` literal, so every opener started a lazy scan hunting a closer that never arrives. A message repeating the tag name in prose went quadratic: 168KB cost 154ms per call, and this runs on the main thread for every streamed chunk, so a long reply is seconds of frozen tab. The pattern it replaced was linear. Now 0.36ms on the same input. Two correctness bugs came with it, both from matching `\s*` around the tag: the pattern could start at one code span's delimiter and finish at another's, so `Open `config.json` <tag> then run `bun test`` lost a backtick; and the whitespace crossed newlines, eating one of the three backticks closing a fenced block that contained a tag, leaving the rest of the message inside the fence. The root problem was three global regexes each guessing at which backticks belong together. They now model what markdown actually does: find code spans by pairing a backtick with the next one on the same line, and unwrap a span only when it genuinely contains a complete tag. Pairing is what makes the neighbour and fence cases correct rather than separately patched. A leftover backtick pressed directly against a tag, with no partner, is still stripped. A negative lookahead stops any scan crossing another opener — the cost bound. Adds tests for the neighbour and fence shapes, and one that pins the complexity by asserting 168KB of repeated-opener prose finishes well inside 50ms; every fixture until now was under 1KB, which is why both quadratics were invisible. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(copilot): address the confirmed review findings Five findings from the review, each reproduced before being fixed and mutation-checked after. The nesting rule on the matched-pair path tested for anything tag-shaped while the streaming path tested for the tag NAMES. Reasoning that mentioned `<div>` or a generic was therefore released as visible prose — the model's thinking on screen because of an incidental angle bracket. Both paths now share one predicate, hasSpecialTagMarker, so they cannot disagree about whether a body was ever a tag. The broad regex keeps its other job: on a JSON body an invented name like `</workflow_resource>` really is stray content. Not changed, and worth saying why: a `<thinking>` body containing a REAL nested tag still releases and renders it. Suppressing it instead would mean the streaming path shows a card and the close then retracts it, which is the defect the previous commit fixed. Security rated the containment loss P2 while noting it grants no capability the top-level path lacks — a stream that can nest a tag can emit one at top level, which already rendered. unclosedTagCannotResolve blanked a full window before viability rejected the body on its first character, which is the common case of a tag name in prose. Testing that first: 43ms per streaming parse at 84KB, now 2ms. The unclosed path sliced the whole remaining buffer and then bounded it, copying the rest of the message per opener per chunk. inspectFrom slices once, bounded. A message that is ONLY a discarded payload rendered the raw JSON: discard emits no segment by design, so it reached the empty-segments fallback, whose job is to never blank a plain-text message. It now knows a discard happened. Pre-existing, but discard only became a first-class outcome on this branch. Three docstrings still pointed at resolveTagAt for decisions the refactor moved into classifyBody and resumeForClass. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * refactor(copilot): quality pass over the parser and its tests Four changes from a reuse/simplification/efficiency/altitude review. No behaviour change; 162 tests unchanged. blankJsonStringLiterals returns the body untouched when it contains no quote. No quote means no string literal, so the loop was copying the body to itself character by character. unclosedTagCannotResolve had learned to short-circuit before calling it; literalTextReason had not, and blanked unconditionally on every already-rejected tag on every later chunk. Putting the guard inside the helper fixes both callers at once. inspectWithin and inspectFrom were near-duplicates added at different times. One function with an optional start expresses both, and keeps the property the second one existed for: slice once, already bounded, never `content.slice(bodyStart)` first and bound after. The frame-replay property was 1727ms — 95% of the file's test time — because it parses every prefix, so message length multiplies into parse count, and the fragment pool included a 6KB filler. Retraction happens AT a frame boundary, not as a function of message size, so that property now draws from the short fragments; the window-crossing filler still gets coverage from the properties that parse each message once. 1727ms to 205ms, same seeds, same assertions. It also now calls replayFrames instead of hand-rolling the stepping loop it already had a helper for. Deferred deliberately, each with a reason: - Collapsing `prose-nested-marker` into `nested-marker`. Its own docstring names the simplification and defers it; it is a behaviour change and wants its own commit and test, which is the pattern the rest of this branch follows. - Bounding hasSpecialTagMarker on the prose path. Costs tens of microseconds on a long reasoning body, but a marker past the bound would flip that body from released to suppressed — a retraction, which is the bug two commits back. - Splitting the parser out of this `'use client'` file. The strongest structural finding: the file cannot be imported by server code, which is why the inbox executor carries its own thinking-strip regex. It is a mechanical move with no logic change and deserves its own PR, not commit 25 of this one. - Generalising the backtick sanitizer past `workspace_resource`, and replacing it with parser-owned backtick consumption. Same reasoning: real, and not here. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * docs(copilot): reattach an orphaned docstring and cut comment noise One real defect. Adding hasSpecialTagMarker put it BETWEEN unclosedTagCannotResolve and the docstring written for it, so two doc blocks sat stacked and the function they described ended up with none. A reader scanning the file would have read the first block as preamble for the wrong function. Moved back, and while there: "14 substring scans" is SPECIAL_TAG_NAMES.length * 2, so adding an eighth tag would have quietly made it wrong — it now says a pass per tag name. The rest is noise removal: - Three comments narrating what the parser used to do. A comment is read by someone looking at the current code, not the diff, and this branch already writes that history at length in its commit messages. - Three millisecond measurements. Each one already stated the durable claim — quadratic, or a copy thrown away per opener per chunk — and then appended a number that will rot. The one measurement kept is the blind-spot paragraph on MAX_UNCLOSED_BODY_SCAN, where the number is what justifies the constant. - Two of the four restatements of "the renderer concatenates adjacent text segments". Kept where it is load-bearing, on pushText and on the test helper. - One claim gone stale in the last commit: the read-budget doc still described two helpers agreeing with each other, after they became one function. Left alone deliberately: the rules that look arbitrary and are not — marker blanking, the differing resume offsets, the accepted trades. Those are why this file reads as heavily commented, and they are the ones worth having. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(copilot): sanitize backticks in one pass so a flush code span survives Review caught a case the previous fix missed. Two passes each decided independently which backticks belonged together, and with no space between a code span and a tag they disagreed: Open `config.json`<tag> ok -> lost the span's closing backtick Open <tag>`config.json` ok -> lost the span's opening backtick My test for this used a space between them, which is exactly why it passed. Both passes are now one left-to-right scan alternating between a code span and a tag with a stray backtick against it. A span consumes its own delimiters as the scan reaches them, so a flush neighbour keeps its pair with no special case — where a second pass had no way to know the backtick was already spoken for. This is the third arrangement of this file; the first two each handled the cases they were written for and broke a different one, which is what two passes guessing at the same question produces. A trailing backtick is only taken as a stray when no further backtick follows on the line. Otherwise it is the opener of the next span. Mutation-checked: removing that lookahead fails the new test and nothing else. Swapping the alternation order changes nothing any fixture covers, so the comment no longer claims the order is load-bearing — it distinguishes only a span that opens flush against a tag and closes elsewhere, which nothing pins. Thirteen shapes verified balanced, including all three flush variants, the fenced block, the neighbour with a space, both one-sided strays, and the mention shapes. 168KB of repeated openers: 0.18ms. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(copilot): rewind the scan-window resume so a straddling opener still parses Applied from an automated code review of this branch. Two findings, both verified by reverting the fix and confirming only the new test fails. `resumeForClass`'s `unexamined` case resumed at exactly `bodyStart + 4096`. That edge is an arbitrary cut, so an opener can begin just before it and finish just after — leaving its `<` behind the cursor. The opener scan only looks forward, so the tag was never found and its payload rendered as raw JSON text on a COMPLETED message, not just mid-stream. Reproducible for every filler length in 4077..4095; the existing borrowed-body test steps in 11-character units and never lands in that band. Backing the resume off by the longest marker guarantees a straddling opener is re-scanned from its `<`. The step is still ~4076 characters, so a long body still costs a bounded number of re-entries. The new test sweeps every offset across the band. The two complexity tests asserted absolute wall-clock ceilings (<50ms, <20ms), which measure the machine as much as the algorithm: they fail on a loaded CI box, and set generously enough not to, they let a genuine quadratic through at the single size they sample. Both now assert the scaling ratio across a 4x input instead (quadratic ~16x, linear ~4x). Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(copilot): trust the raw body for markers once it is known not to be JSON `literalTextReason` blanks a body's quoted regions before scanning it for tag markers, so that syntax quoted inside a JSON string is not mistaken for a real nested tag. That blanking assumes quotes delimit JSON strings. One unbalanced `"` breaks the assumption: everything after it is treated as string content, which can hide a genuine marker. The verdict then degrades from `foreign-markers` to `never-a-payload`, and the resume changes with it — from the marker offset to past the close — flattening a real tag inside the span. A card already on screen un-renders into raw JSON when the closing tag finally arrives, and a valid tag after it never renders. Blanking is only meaningful while the body might BE JSON. Once viability or a failed parse has proved it never was, that premise is void and the raw text is the honest evidence, so rescan it and resume at the marker. Both routes to "never JSON" now funnel through one branch. The rescan applies to the failed-parse route too, not only the viability one — patching just the latter leaves the same defect reachable through the former. Behaviour for a body that IS valid JSON is untouched: a well-formed payload that fails its shape guard is still discarded, and tag syntax quoted inside a valid payload is still invisible to the scan. Adds the repro as two tests — the settled parse, and frame-by-frame so the un-render is pinned directly — plus two unbalanced-quote fragments to the property corpus. Reverting the rescan fails exactly those two tests. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * refactor(copilot): share the scaling-ratio harness between the two perf tests Both complexity tests hand-rolled the same 15-line harness — build a repeated tag mention, take the fastest of five runs at two input sizes, assert the ratio — differing only in which function they timed. Changing the run count, the sample sizes, or the threshold meant editing both in lockstep. Extracted to `scalingRatioOver4x`, following the existing `*-test-helpers.ts` convention in this tree. The rationale for asserting a ratio rather than a wall-clock ceiling now lives in one place instead of being paraphrased twice. Also drops a redundant disjunct in the opener scan: `nearestStart` and `nearestTagName` are only ever assigned together, so `nearestStart === -1` holds exactly when the name is empty. Testing the name alone is the same check and is the one that narrows the union for `resolveTagAt`. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * docs(copilot): correct a resume comment the rewind fix left inaccurate The `unexamined` case claimed "everything read is emitted as text by the caller". That was true when the resume was exactly the window edge, but the straddling-opener rewind holds the last marker's worth of the window back so it can be re-scanned rather than flattened — so the sentence contradicted the paragraph directly beneath it. Nothing is lost either way; the caller emits up to wherever this resumes. Also drops two "Round-N class:" prefixes from test comments. They point at review rounds of this PR, which mean nothing to a reader after it merges; the sentences that follow already say what the bug was. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * test(copilot): pin the blanking rule with a body staging cannot recover CI runs the merge with staging, and staging's desktop PR (#5998) taught `parseSpecialTagData` to recover a failed `<question>` body's prompt and render it as text instead of returning null. That recovery lands before `classifyBody` is ever consulted, so this fixture — whose quoted `</options>` sat inside its `prompt` — stopped exercising the blanking rule and started asserting the recovery. Merged, it rendered "A use </options> here? B" instead of "A B". Moving the quoted marker to a non-`prompt` field restores what the test is for: a marker inside a JSON string must be blanked before the scan, or a broken payload gets classified as literal text and its raw JSON is shown. A body with no recoverable prompt reaches `discard` on both sides of the merge, matching the prompt-less fixture the sibling test above already uses. Behaviour is unchanged on either branch alone; only the fixture moved. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * test(copilot): cover every tag in the property invariants, and pin that it stays that way `VALID_TAGS` and `NEEDLES` hand-picked three or four of the seven tags the parser resolves. `credential`, `usage_upgrade`, and `mothership-error` were exercised by no invariant at all — not the card-count property, not retraction-across-frames, not settled-vs-last-frame — and nothing failed to say so. The property block's whole argument is that it covers combinations no fixed example set would, which was only true for four sevenths of the tag space. Fixtures are now keyed by tag name and checked against SPECIAL_TAG_NAMES, so adding a tag without a fixture fails a test instead of quietly falling outside every property here. `thinking` is listed separately: it renders nothing, so it cannot carry a card invariant. SPECIAL_TAG_NAMES is exported for that check, matching the five sibling `*_TYPES` unions in the same module that are already exported. NEEDLES derives from it too, so the memoization test searches every opener the parser does. All three newly covered tags pass every invariant — this closes a coverage gap, it does not fix a bug. Removing any one fixture fails the new guard. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * docs(copilot): state the actual bound on the thinking nesting rule The docstring implied generics are excluded from the marker check. They are not: the match is a substring test, so `Promise<void>` is safe only because `void` is not a tag name, while `Promise<options>` does match and would release a thinking body as text. Says so plainly now, with why it is left as-is: the boundary check that would narrow it wants a lookbehind, which is Safari 16.4+ and would be a parse-time SyntaxError on the versions this app still supports — a dead client chunk is a worse outcome than the bug. Reaching it also needs an inline `<thinking>` body, which the agent no longer emits, discussing a type named exactly after a tag. Comment only; no behaviour change. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
4 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Summary
Companion: https://github.com/simstudioai/mothership/pull/374
Type of Change
Testing
Manual
Checklist