fix(files): fail-close base-less previews + operation-based stream hold

Cursor/Greptile round 3 (High + Medium) — remove the fragile string-prefix
"extend gate", which was the root of both findings:

- Server: `buildFilePreviewText` now fails closed for an `append` whose base
  content hasn't loaded (returns undefined, like patch/update), so a base-less
  fragment never reaches the client. This eliminates the base-less wipe at
  settle (Greptile P1) at the source; an empty file (existingContent === '')
  still previews normally.
- Client: the collab streaming tick no longer string-prefixes the raw preview
  against the editor's canonical markdown (the '*' vs '-' / emphasis mismatch
  that froze every append frame — Cursor). The mid-stream hold is now purely
  operation-based: `update` waits for settle; append/patch/create apply each
  frame via the (peer-safe) shadow reconcile. lastStreamedBodyRef is now a plain
  dedup guard, not a prefix baseline.

Keeps the shadow, durable write, and SYNC_NO_PERSIST unchanged.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/rich-markdown-editor.tsx

@@ -85,10 +85,10 @@ interface RichMarkdownEditorProps {
    */
   streamIsIncremental?: boolean
   /**
-   * The agent edit operation driving the stream, when known (`create`/`append`/`update`/`patch`). Used
-   * only to relax the "must extend" gate for `patch` (which legitimately replaces a mid-document region):
-   * every other operation's snapshot must extend what's shown, so a base-less `append` fragment can't
-   * reconcile the live doc to a wipe.
+   * The agent edit operation driving the stream, when known (`create`/`append`/`update`/`patch`). In the
+   * collaborative path it decides only whether to stream mid-flight: an `update` (from-scratch rewrite) is
+   * HELD until settle so the open doc doesn't collapse to a partial result, while `append`/`patch`/`create`
+   * apply each frame.
    */
   streamOperation?: string
   disableStreamingAutoScroll?: boolean
@@ -339,11 +339,11 @@ export function LoadedRichMarkdownEditor({
     streamingAtMountRef.current ? null : splitFrontmatter(content).body
   )
   /**
-   * The body the AGENT last streamed into the collaborative doc — the extend-gate baseline for the collab
-   * streaming path. Written ONLY at stream start (snapshotting the pre-stream base) and by the streaming
-   * tick, never by `onUpdate`, so a concurrent PEER edit (which does clobber {@link lastSyncedBodyRef} via
-   * `onUpdate`) can't make the agent's growing snapshot stop prefixing the shown body and stall the stream.
-   * Reset to `null` on settle so the next stream re-captures its own baseline.
+   * The body the AGENT last applied into the collaborative doc — a dedup guard for the collab streaming
+   * tick, so an unchanged frame skips a redundant shadow reconcile/reparse. Written ONLY by the streaming
+   * tick (never by `onUpdate`), and reset to `null` on settle for the next stream. It is NOT a string-prefix
+   * baseline: the mid-stream hold is decided by operation (`update` waits for settle), not by comparing the
+   * raw preview against the editor's canonical markdown.
    */
   const lastStreamedBodyRef = useRef<string | null>(null)
   const onChangeRef = useRef(onChange)
@@ -872,13 +872,10 @@ export function LoadedRichMarkdownEditor({
         // re-runs and applies once it lands (the read-only placeholder shows the base content meanwhile —
         // see `showPlaceholder`).
         if (!collabReady) return
-        // Open the stream's shadow on the FIRST ready frame — BEFORE the extend gate — so its shadow
-        // captures the pre-stream base (immune to later peer edits) even for an `update` whose every frame
-        // is gated out until settle. Snapshot that base as the agent's private extend-gate baseline.
-        if (agentStreamSessionRef.current === null) {
-          agentStreamSessionRef.current = beginAgentStream(editor)
-          lastStreamedBodyRef.current = lastSyncedBodyRef.current
-        }
+        // Open the stream's shadow on the FIRST ready frame so it captures the pre-stream base (immune to
+        // later peer edits) — including for an `update`, whose frames are all held until settle, so settle
+        // still has a shadow through which to apply the final rewrite.
+        agentStreamSessionRef.current ??= beginAgentStream(editor)
         const session = agentStreamSessionRef.current
         const body = splitFrontmatter(content).body
         if (body === lastStreamedBodyRef.current) return
@@ -890,15 +887,11 @@ export function LoadedRichMarkdownEditor({
             streamRafRef.current = null
             return
           }
-          const shownBody = lastStreamedBodyRef.current
-          const extendsShown = shownBody === null || pending.startsWith(shownBody)
-          // Every snapshot except a mid-document `patch` must EXTEND what the AGENT last streamed: a
-          // from-scratch rebuild (`create`/`update`) is only revealed as it grows, and an `append`
-          // snapshot that doesn't extend the base is a base-less fragment (the server emits one before the
-          // base loads) which would reconcile the seeded doc down to a wipe. Only `patch` replaces a
-          // mid-region. The baseline is the agent's own last frame (not the editor body), so a concurrent
-          // peer edit can't make the growing snapshot stop prefixing it and stall the stream.
-          if (!extendsShown && streamOperationRef.current !== 'patch') {
+          // Hold a from-scratch rewrite (`update`) until settle so the open doc doesn't collapse to a
+          // partial rewrite mid-stream (matching `main`). `append`/`patch`/`create` apply each frame — the
+          // shadow reconcile is peer-safe, and base-less `append` fragments no longer reach the client (the
+          // server fail-closes them), so there is nothing here to string-prefix or wipe-guard against.
+          if (streamOperationRef.current === 'update') {
             streamRafRef.current = null
             return
           }
@@ -929,11 +922,10 @@ export function LoadedRichMarkdownEditor({
         cancelAnimationFrame(streamRafRef.current)
         streamRafRef.current = null
       }
-      // Settle: apply the FINAL body once so the Y.Doc exactly equals the streamed result — even when
-      // every mid-stream frame was gated out (an `update` rewrite never extends the base) or the stream
-      // finished before the seed, cases where no frame applied. Reuse the stream's shadow when it exists
-      // (seeded from the pre-stream base, so peer edits survive); otherwise open one on demand. The
-      // durable server write then lands as a noop diff.
+      // Settle: apply the FINAL body once so the Y.Doc exactly equals the streamed result — even when no
+      // frame applied mid-stream (an `update` is held until settle, or the stream finished before the
+      // seed). Reuse the stream's shadow when it exists (seeded from the pre-stream base, so peer edits
+      // survive); otherwise open one on demand. The durable server write then lands as a noop diff.
       if (wasStreamingRef.current && collabReady) {
         wasStreamingRef.current = false
         const finalBody = splitFrontmatter(content).body

apps/sim/lib/copilot/tools/server/files/file-preview.test.ts

@@ -31,6 +31,29 @@ describe('buildFilePreviewText', () => {
     ).toBe('line one\nline two')
   })
 
+  it('fails closed (returns undefined) for an append when the base content has not loaded', () => {
+    // A base-less append preview is just the streamed fragment; a collaborative editor applying it as the
+    // full body would reconcile the seeded doc down to that fragment (a wipe). It must fail closed until
+    // the base loads, exactly like patch/update.
+    expect(
+      buildFilePreviewText({
+        operation: 'append',
+        existingContent: undefined,
+        streamedContent: 'orphan fragment',
+      })
+    ).toBeUndefined()
+  })
+
+  it('still previews an append into an EMPTY file (existingContent is "", not undefined)', () => {
+    expect(
+      buildFilePreviewText({
+        operation: 'append',
+        existingContent: '',
+        streamedContent: 'first line',
+      })
+    ).toBe('first line')
+  })
+
   it('applies anchored replace_between previews', () => {
     expect(
       buildFilePreviewText({

apps/sim/lib/copilot/tools/server/files/file-preview.ts

@@ -182,10 +182,15 @@ export function buildFilePreviewText({
   }
 
   if (operation === 'append') {
-    if (existingContent !== undefined) {
-      return buildAppendPreview(existingContent, streamedContent)
+    // Fail closed (like `patch`/`update` below) when the base file content has not loaded yet: a base-less
+    // `append` preview is just the streamed fragment, and a collaborative editor applying it as the full
+    // body would reconcile the seeded doc down to that fragment (a wipe). Skipping the preview until the
+    // base is available costs only a brief render delay; the final durable `edit_content` write is
+    // authoritative. An empty file has `existingContent === ''` (defined), so it is unaffected.
+    if (existingContent === undefined) {
+      return undefined
     }
-    return streamedContent
+    return buildAppendPreview(existingContent, streamedContent)
   }
 
   if (existingContent === undefined) {