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>

Author: j15z

apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.test.ts

@@ -358,6 +358,24 @@ describe('parseSpecialTags with <question>', () => {
     expect(renderedText(segments)).toBe(raw)
   })
 
+  it('settles a prose mention at any length, but defers a payload that closes past the window', () => {
+    // The scan window's accepted blind spot, pinned so it stays a decision.
+    //
+    // A mention in prose settles at its FIRST character however long the message
+    // runs — prose does not open with `{`, so viability fails immediately.
+    const mention = `see <workspace_resource> ${'long prose. '.repeat(600)}`
+    expect(parseSpecialTags(mention, true).hasPendingTag).toBe(false)
+
+    // But a JSON body whose top-level value closes BEYOND the window still reads
+    // as a viable prefix, so the tail stays hidden until the stream ends. Needs a
+    // payload several times larger than any tag emits, and it is lossless once
+    // complete — the cost of bounding a scan that otherwise stalls the main
+    // thread.
+    const oversized = `see <workspace_resource>{"type":"file","note":"${'x'.repeat(5000)}"} and then prose.`
+    expect(parseSpecialTags(oversized, true).hasPendingTag).toBe(true)
+    expect(renderedText(parseSpecialTags(oversized, false).segments)).toBe(oversized)
+  })
+
   it('still renders a matched pair whose body IS valid', () => {
     const raw =
       'see <workspace_resource>{"type":"file","path":"files/a.md","title":"a.md"}</workspace_resource> ok'

apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.tsx

@@ -489,16 +489,29 @@ const JSON_BODY_TAG_NAMES: ReadonlySet<(typeof SPECIAL_TAG_NAMES)[number]> = new
 )
 
 /**
- * How much of an unclosed body to inspect per parse.
+ * How much of a body to inspect per parse, on both the unclosed and matched-pair
+ * paths.
  *
- * Both rules in {@link unclosedTagCannotResolve} decide on their FIRST piece of
- * evidence — the first foreign marker, or the first character that breaks JSON
- * viability — so a bounded window reaches the same verdict as the full remainder
- * for any real payload. Unbounded, the check is O(remaining length) and runs
- * once per opener inside a parse that re-runs for every streamed chunk, so a
- * long reply repeatedly mentioning a tag name in prose costs seconds of
- * main-thread time. Evidence past the window only defers the decision to a later
- * chunk, which is the same conservative direction the rules already take.
+ * The rules in {@link unclosedTagCannotResolve} and {@link literalTextReason}
+ * decide on their FIRST piece of evidence — the first foreign marker, or the
+ * first character that breaks JSON viability — so a bounded window reaches the
+ * same verdict as the full remainder for any payload a tag actually carries.
+ * Unbounded, the check is O(body length) and runs once per opener inside a parse
+ * that re-runs for every streamed chunk: a long reply repeatedly mentioning a tag
+ * name cost seconds of main-thread time, and one 58KB reply whose early close was
+ * misspelled — so a single body stretched most of the message — cost 242ms per
+ * parse against 35ms bounded.
+ *
+ * The window's one blind spot, and why it is accepted: 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 stays hidden until the stream
+ * ends rather than settling mid-stream. It is lossless — the completed parse
+ * renders every character — and it needs a payload several times larger than any
+ * tag emits (a `<workspace_resource>` runs ~100 characters, a `<question>` card
+ * under ~1500). A mention in prose settles at its first character at any length,
+ * because prose does not open with `{`. Widening or removing the window to close
+ * that gap would trade a measured, reachable main-thread freeze for a
+ * hypothetical one.
  */
 const MAX_UNCLOSED_BODY_SCAN = 4096