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>

Author: j15z

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

@@ -353,6 +353,52 @@ describe('parseSpecialTags with <question>', () => {
     expect(renderedText(segments)).toContain('</workflow_resource>')
   })
 
+  it('finds a nested tag an unbalanced quote hid from the blanked scan', () => {
+    // One stray `"` is enough to make blankJsonStringLiterals treat the REST of
+    // the body as a string literal, hiding the real `<options>` marker from the
+    // scan. The verdict then degrades from `foreign-markers` to `never-a-payload`
+    // and resumes past the close, flattening both nested tags into one literal
+    // span — so a card already on screen un-renders when the close arrives.
+    //
+    // Blanking is only meaningful while the body might BE json. Once viability
+    // has proved it never was, the raw text is the honest evidence.
+    const raw =
+      'Saved <workspace_resource>the notes file "notes.md and here is what to do next: ' +
+      '<options>[{"title":"Ship it","description":"Open the PR"}]</options>\n' +
+      'Full path: <workspace_resource>{"type":"file","path":"files/a.md","title":"a.md"}</workspace_resource>'
+
+    const { segments } = parseSpecialTags(raw, false)
+    expect(segments.filter((segment) => segment.type === 'options')).toHaveLength(1)
+    expect(segments.filter((segment) => segment.type === 'workspace_resource')).toHaveLength(1)
+    // Balancing the quote must reach the same two cards — the quote is the only
+    // difference, so this pins that it was never load-bearing for the outcome.
+    const balanced = raw.replace('the notes file "notes.md', 'the notes file notes.md')
+    const control = parseSpecialTags(balanced, false).segments
+    expect(control.filter((segment) => segment.type === 'options')).toHaveLength(1)
+    expect(control.filter((segment) => segment.type === 'workspace_resource')).toHaveLength(1)
+  })
+
+  it('never un-renders that card as the closing tag arrives', () => {
+    // The frame-level face of the case above, and the invariant it broke: the
+    // options card is on screen for many frames before the final `>` lands. A
+    // card that renders must never revert to raw text.
+    const raw =
+      'Saved <workspace_resource>the notes file "notes.md and here is what to do next: ' +
+      '<options>[{"title":"Ship it","description":"Open the PR"}]</options>\n' +
+      'Full path: <workspace_resource>{"type":"file","path":"files/a.md","title":"a.md"}</workspace_resource>'
+
+    let sawCard = false
+    for (let end = 1; end <= raw.length; end++) {
+      const { segments } = parseSpecialTags(raw.slice(0, end), true)
+      const hasCard = segments.some((segment) => segment.type === 'options')
+      if (hasCard) sawCard = true
+      expect(!sawCard || hasCard, `options card retracted at frame ${end}`).toBe(true)
+    }
+    expect(sawCard).toBe(true)
+    // ...and the settled parse still has it.
+    expect(parseSpecialTags(raw, false).segments.some((s) => s.type === 'options')).toBe(true)
+  })
+
   it('does not delete tag syntax quoted inside the body it rescans', () => {
     // The rescan decides on the BLANKED body, so a tag quoted inside a JSON
     // string is invisible to it. Resuming at the opener would re-scan that
@@ -849,6 +895,8 @@ describe('parser properties', () => {
     "<workspace_resource>{'type':'file'}</workspace_resource> single quotes. ",
     '<workspace_resource>the gmail-agent workflow</workspace_resource> prose body. ',
     '<thinking>reasoning <options> with a nested marker</thinking> after. ',
+    '<workspace_resource>the notes file "notes.md unbalanced quote</workspace_resource> after. ',
+    '<workspace_resource>notes "unbalanced then <options> marker</workspace_resource> tail. ',
     '\n\nA paragraph break above. ',
     `${'long filler prose. '.repeat(300)}crossing the scan window. `,
   ]

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

@@ -887,13 +887,28 @@ function classifyBody(tagName: (typeof SPECIAL_TAG_NAMES)[number], body: string)
     return { kind: 'nested-marker', offsetInBody: verdict.markerOffset }
   }
   if (inspected.truncated) return { kind: 'unexamined' }
-  if (verdict?.reason === 'never-a-payload') return { kind: 'never-json' }
 
   // Dropping text is only defensible for a payload the agent actually FORMED.
   // `{the Q4 report}` is prose in braces and `{type: "file"}` is an ordinary
   // model slip; bracket depth cannot tell either from a real payload, only a
-  // parse can.
-  if (isJsonBodied && !isParseableJson(body)) return { kind: 'never-json' }
+  // parse can. Both routes to that answer are funnelled through one place so the
+  // rescan below cannot be added to one and forgotten on the other.
+  const neverJson =
+    verdict?.reason === 'never-a-payload' || (isJsonBodied && !isParseableJson(body))
+
+  if (neverJson) {
+    // literalTextReason blanked this body's quoted regions on the assumption it
+    // was JSON. It never was, so that assumption is void — and a body with an
+    // odd number of `"` blanks the WRONG regions, which can hide a real marker
+    // and turn what should be `nested-marker` into `never-json`. The difference
+    // is not academic: `never-json` resumes past the close, flattening a genuine
+    // tag inside the span, so a card already on screen un-renders when the close
+    // finally arrives. With the JSON premise gone, the raw text is the honest
+    // evidence, and a marker in it means the close we matched belongs elsewhere.
+    const rawMarker = TAG_SHAPED_MARKER.exec(inspected.text)
+    if (rawMarker) return { kind: 'nested-marker', offsetInBody: rawMarker.index }
+    return { kind: 'never-json' }
+  }
 
   return { kind: 'broken-payload' }
 }