fix(files): open the stream shadow at start + private extend baseline

Cursor round 2:
- High (settle skips apply without session): the stream shadow is now opened on
  the first ready frame, BEFORE the extend gate — so an `update` rewrite (whose
  every frame is gated out until settle) and a stream that finishes before seed
  still get a session, and settle applies the final body via the reused-or-on-demand
  shadow instead of leaving the doc stale until the durable reconcile.
- Medium (peer edits stall the stream): the extend gate now reads a private
  `lastStreamedBodyRef` (the agent's own last frame), snapshotted at stream start,
  not `lastSyncedBodyRef` which `onUpdate` clobbers on peer edits — so a collaborator
  typing can't make the growing snapshot stop prefixing the shown body and freeze it.
- Medium (multi-replica over-persist): pre-existing, documented "safe over-persist"
  (a peer task tails the frame as REDIS_ORIGIN and marks edited) — refreshed the
  stale comment to describe the SYNC_NO_PERSIST source; copilot's edit_content write
  remains the authoritative durable persist.

Author: waleedlatif1

apps/realtime/src/handlers/file-doc.ts

@@ -719,10 +719,12 @@ function getOrCreateRoom(io: Server, ref: RoomRef): FileDocRoom {
     // snapshot on catch-up (REDIS_SNAPSHOT_ORIGIN) also counts: it folds real edits into one frame, so a
     // fresh task catching up purely from it must not treat the doc as unedited. The seed transition
     // itself is never counted, so a seeded-but-unedited doc is never projected back over the file. NOTE:
-    // in the multi-replica path a copilot merge is NOT excluded — it round-trips through the stream as
-    // REDIS_ORIGIN, indistinguishable from a peer edit, so it marks `edited`. That only ever causes an
-    // extra idempotent persist of content copilot already wrote directly (safe over-persist, never a lost
-    // edit); the single-replica path applies the merge locally with no origin and does not count it.
+    // an agent-streamed frame ({@link FILE_DOC_MESSAGE_TYPE.SYNC_NO_PERSIST}) is not counted on the
+    // ORIGINATING task (it applies under an AgentSyncOrigin — see the handler), but in the multi-replica
+    // path it is published to the stream and PEER tasks apply it as REDIS_ORIGIN, indistinguishable from a
+    // peer edit, so it marks `edited` there. That only ever causes an extra idempotent persist of content
+    // the copilot's final `edit_content` write persists durably anyway (safe over-persist, never a lost
+    // edit); fully suppressing it would require tagging the stream entry as no-persist across replicas.
     const seededBefore = room.seededObserved
     if (isDocSeeded(room.doc)) room.seededObserved = true
     if (

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

@@ -338,6 +338,14 @@ export function LoadedRichMarkdownEditor({
   const lastSyncedBodyRef = useRef<string | null>(
     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.
+   */
+  const lastStreamedBodyRef = useRef<string | null>(null)
   const onChangeRef = useRef(onChange)
   onChangeRef.current = onChange
   const onSaveShortcutRef = useRef(onSaveShortcut)
@@ -864,22 +872,32 @@ 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
+        }
+        const session = agentStreamSessionRef.current
         const body = splitFrontmatter(content).body
-        if (body === lastSyncedBodyRef.current) return
+        if (body === lastStreamedBodyRef.current) return
         pendingStreamBodyRef.current = body
         if (streamRafRef.current !== null) return
         const tick = () => {
           const pending = pendingStreamBodyRef.current
-          if (pending === null || pending === lastSyncedBodyRef.current) {
+          if (pending === null || pending === lastStreamedBodyRef.current) {
             streamRafRef.current = null
             return
           }
-          const shownBody = lastSyncedBodyRef.current
+          const shownBody = lastStreamedBodyRef.current
           const extendsShown = shownBody === null || pending.startsWith(shownBody)
-          // Every snapshot except a mid-document `patch` must EXTEND what's shown: 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` legitimately replaces a mid-region.
+          // 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') {
             streamRafRef.current = null
             return
@@ -893,16 +911,14 @@ export function LoadedRichMarkdownEditor({
           }
           const el = containerRef.current
           const pinnedToBottom = el ? el.scrollHeight - el.scrollTop - el.clientHeight < 80 : false
-          agentStreamSessionRef.current ??= beginAgentStream(editor)
-          const session = agentStreamSessionRef.current
           // Defensive: a ready collab editor always has a ySync binding, so this applies; if one is
           // somehow absent, bail this frame without advancing rather than looping.
           if (!session || !applyAgentStreamFrame(editor, session, pending)) {
             streamRafRef.current = null
             return
           }
           streamRafRef.current = null
-          lastSyncedBodyRef.current = pending
+          lastStreamedBodyRef.current = pending
           lastStreamParseAtRef.current = performance.now()
           if (!disableStreamingAutoScroll && el && pinnedToBottom) el.scrollTop = el.scrollHeight
         }
@@ -913,22 +929,20 @@ export function LoadedRichMarkdownEditor({
         cancelAnimationFrame(streamRafRef.current)
         streamRafRef.current = null
       }
-      // Settle: once seeded, apply the final body once (the last streaming frame may have been throttled)
-      // so the Y.Doc exactly equals the streamed result; the durable server write then lands as a noop
-      // diff. If the seed has not arrived, keep `wasStreamingRef` set so the post-seed re-run applies.
+      // 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.
       if (wasStreamingRef.current && collabReady) {
         wasStreamingRef.current = false
         const finalBody = splitFrontmatter(content).body
-        const session = agentStreamSessionRef.current
+        const session = agentStreamSessionRef.current ?? beginAgentStream(editor)
         agentStreamSessionRef.current = null
+        lastStreamedBodyRef.current = null
         if (session) {
           runOffRender(() => {
-            if (
-              finalBody !== lastSyncedBodyRef.current &&
-              applyAgentStreamFrame(editor, session, finalBody)
-            ) {
-              lastSyncedBodyRef.current = finalBody
-            }
+            applyAgentStreamFrame(editor, session, finalBody)
           })
           // Free the shadow with an UNGUARDED microtask (not `runOffRender`): a rapid follow-up stream
           // can supersede the run token and drop the apply above, but the shadow must always be
@@ -1042,6 +1056,7 @@ export function LoadedRichMarkdownEditor({
         endAgentStream(agentStreamSessionRef.current)
         agentStreamSessionRef.current = null
       }
+      lastStreamedBodyRef.current = null
     },
     []
   )