@agent-native/core 0.92.9 → 0.92.11

package/corpus/core/src/cli/skills.ts

@@ -631,6 +631,20 @@ replace them with copied \`srcdoc\` HTML unless the user explicitly asks for a
 frozen snapshot. To change a state, rerun \`add-localhost-screens\` with the new
 path/query or duplicate the screen and update the copy's URL metadata.
 
+## React Source Writeback
+
+- Use compiler/debug provenance (project-relative file, line, column,
+  component, and runtime multiplicity) to locate React/TSX source. Treat it as
+  evidence, not as permission for a generic AST structural transform.
+- Reparenting, grouping/ungrouping, wrappers, dynamic expressions, repeated
+  \`.map()\` instances, shared components, and cross-file changes go through the
+  coding agent with exact subject/target anchors and their runtime
+  relationship.
+- Before each write, read the file and pass its exact \`versionHash\` to
+  \`write-local-file\` with \`requireExpectedVersionHash: true\`; on conflict,
+  re-read and re-plan. Keep the optimistic preview until HMR/runtime confirms
+  the result. Human write consent remains mandatory and agents cannot grant it.
+
 ## Verification
 
 - \`list-localhost-connections\` returns the expected connection and routes.

package/corpus/core/src/client/AssistantChat.tsx

@@ -55,9 +55,11 @@ import {
   appendAgentChatContextToMessage,
   formatAgentChatContextItemsForPrompt,
   getAgentChatContextState,
+  isAgentChatSubmitCancelled,
   normalizeAgentChatContextItem,
   publishAgentChatContextItems,
   refreshAgentChatContext,
+  reportAgentChatSubmitResult,
   subscribeAgentChatContext,
   type AgentChatContextItem,
 } from "./agent-chat.js";
@@ -197,6 +199,8 @@ export type AgentRecoveryAction = "continue" | "retry";
 export interface AssistantChatSendOptions {
   trackInRunsTray?: boolean;
   requestMode?: AgentRequestMode;
+  /** Correlates with `AGENT_CHAT_SUBMIT_RESULT_EVENT` — see agent-chat.ts. */
+  submitMessageId?: string;
 }
 
 function createUserMessageRunConfig(
@@ -3651,9 +3655,12 @@ const AssistantChatInner = forwardRef<
       trackInRunsTray = false,
       preserveReconnectAutoRecoveryBudget = false,
       hideUserMessage = false,
+      submitMessageId?: string,
     ) => {
+      if (isAgentChatSubmitCancelled(submitMessageId)) return;
       if (agentEngineConfigured.state === "missing") {
         void ensureAgentEngineReadyForSubmit();
+        reportAgentChatSubmitResult(submitMessageId, false, "missing-engine");
         return;
       }
       if (!preserveReconnectAutoRecoveryBudget) {
@@ -3687,8 +3694,10 @@ const AssistantChatInner = forwardRef<
             ? err.message
             : "Attachment could not be processed.";
         setComposerError(msg);
+        reportAgentChatSubmitResult(submitMessageId, false, "attachment-error");
         return;
       }
+      if (isAgentChatSubmitCancelled(submitMessageId)) return;
       const imageAttachments = createAgentImageAttachments(images);
       const allAttachments = [
         ...(queuedAttachments ?? []),
@@ -3782,6 +3791,11 @@ const AssistantChatInner = forwardRef<
               setComposerError(
                 `"${rejected.name}" makes the message too large to send (combined attachments must be under ${Math.round(MAX_ESTIMATED_BODY_BYTES / 1024 / 1024)} MB). Remove it or use a smaller image.`,
               );
+              reportAgentChatSubmitResult(
+                submitMessageId,
+                false,
+                "attachment-too-large",
+              );
               return;
             }
           }
@@ -3789,6 +3803,7 @@ const AssistantChatInner = forwardRef<
         }
       }
       // ── End body-size guard ──────────────────────────────────────────
+      if (isAgentChatSubmitCancelled(submitMessageId)) return;
       // Snapshot the exec mode at enqueue time when the caller didn't
       // pass an explicit override. Without this, a plan-mode message that
       // sits in the queue runs as 'act' if the user flips the global toggle
@@ -3863,9 +3878,16 @@ const AssistantChatInner = forwardRef<
           } as Parameters<typeof threadRuntime.append>[0]);
         } catch (error) {
           setOptimisticRunning(false);
+          reportAgentChatSubmitResult(submitMessageId, false, "append-failed");
           throw error;
         }
       }
+      // The turn is now either queued behind the active run or already a
+      // visible message — either way it has reached the chat. This is
+      // intentionally reported before the agent's response resolves: a
+      // caller like sendToAgentChatAndConfirm only needs to know the submit
+      // wasn't silently dropped, not whether the run itself later succeeds.
+      reportAgentChatSubmitResult(submitMessageId, true);
       if (submitted.includesContext) {
         updateComposerContextItems(() => []);
       }
@@ -3927,6 +3949,9 @@ const AssistantChatInner = forwardRef<
           undefined,
           false,
           options?.trackInRunsTray === true,
+          false,
+          false,
+          options?.submitMessageId,
         );
       },
       prefillMessage(text: string) {

package/corpus/core/src/client/MultiTabAssistantChat.tsx

@@ -30,8 +30,10 @@ import {
   claimAgentChatSubmit,
   drainBufferedAgentChatOpenRequests,
   drainBufferedAgentChatSubmits,
+  isAgentChatSubmitCancelled,
   normalizeAgentChatContextItem,
   parseSubmitChatMessage,
+  reportAgentChatSubmitResult,
   type AgentChatContextItem,
 } from "./agent-chat.js";
 import { agentNativePath, appPath } from "./api-path.js";
@@ -79,6 +81,8 @@ interface PendingSend {
   submit: boolean;
   trackInRunsTray?: boolean;
   requestMode?: "act" | "plan";
+  /** Correlates with `AGENT_CHAT_SUBMIT_RESULT_EVENT` — see agent-chat.ts. */
+  submitMessageId?: string;
 }
 
 /**
@@ -93,14 +97,18 @@ interface PendingDelivery {
 
 /** The single path that hands a queued send to a mounted chat ref. */
 function deliverPendingSend(ref: AssistantChatHandle, send: PendingSend): void {
+  if (isAgentChatSubmitCancelled(send.submitMessageId)) return;
   if (!send.submit) {
     ref.prefillMessage(send.message);
     return;
   }
-  if (send.trackInRunsTray || send.requestMode) {
+  if (send.trackInRunsTray || send.requestMode || send.submitMessageId) {
     ref.sendMessage(send.message, send.images, {
       ...(send.trackInRunsTray ? { trackInRunsTray: true } : {}),
       ...(send.requestMode ? { requestMode: send.requestMode } : {}),
+      ...(send.submitMessageId
+        ? { submitMessageId: send.submitMessageId }
+        : {}),
     });
   } else {
     ref.sendMessage(send.message, send.images);
@@ -1767,6 +1775,7 @@ export function MultiTabAssistantChat({
         background,
         submit,
         images,
+        submitMessageId,
       } = parsed;
       const requestedTabId = parsed.tabId;
       const requestMode =
@@ -1777,7 +1786,14 @@ export function MultiTabAssistantChat({
       if (openSidebar !== false && !background) {
         window.dispatchEvent(new CustomEvent("agent-panel:open"));
       }
-      if (postMessageSubmissionsDisabled) return;
+      if (postMessageSubmissionsDisabled) {
+        reportAgentChatSubmitResult(
+          submitMessageId,
+          false,
+          "composer-disabled",
+        );
+        return;
+      }
 
       // Plan mode is sent as request metadata by the chat adapter. Keep the
       // user-visible message clean so mode instructions never enter history.
@@ -1791,9 +1807,11 @@ export function MultiTabAssistantChat({
         submit,
         ...(background ? { trackInRunsTray: true } : {}),
         ...(requestMode ? { requestMode } : {}),
+        ...(submitMessageId ? { submitMessageId } : {}),
       };
 
       const sendToTab = (threadId: string) => {
+        if (isAgentChatSubmitCancelled(submitMessageId)) return;
         // If a model override was specified, apply it only if we recognize it
         if (model) {
           const matchedGroup = availableModels.find((g) =>
@@ -1826,8 +1844,17 @@ export function MultiTabAssistantChat({
 
       if (newTab) {
         const previousTabId = activeThreadIdRef.current;
-        createThread(requestedTabId).then((newId) => {
-          if (newId) {
+        createThread(requestedTabId)
+          .then((newId) => {
+            if (isAgentChatSubmitCancelled(submitMessageId)) return;
+            if (!newId) {
+              reportAgentChatSubmitResult(
+                submitMessageId,
+                false,
+                "thread-create-failed",
+              );
+              return;
+            }
             newThreadIds.current.add(newId);
             if (background) {
               mountedTabsRef.current.add(newId);
@@ -1842,8 +1869,14 @@ export function MultiTabAssistantChat({
             if (background && previousTabId) {
               switchThreadState(previousTabId);
             }
-          }
-        });
+          })
+          .catch(() => {
+            reportAgentChatSubmitResult(
+              submitMessageId,
+              false,
+              "thread-create-failed",
+            );
+          });
       } else {
         const currentTabId = activeThreadIdRef.current;
         if (currentTabId) {
@@ -1901,6 +1934,7 @@ export function MultiTabAssistantChat({
     const active = activeThreadIdRef.current;
     const remaining: PendingDelivery[] = [];
     for (const delivery of pendingDeliveries.current) {
+      if (isAgentChatSubmitCancelled(delivery.send.submitMessageId)) continue;
       const threadId = delivery.threadId ?? active ?? null;
       const ref = threadId ? chatRefs.current.get(threadId) : null;
       if (threadId && ref) {

package/corpus/core/src/client/agent-chat.ts

@@ -96,6 +96,11 @@ export interface AgentChatMessage {
    * focusing it or opening the sidebar. The message runs silently.
    */
   background?: boolean;
+  /**
+   * Stable id used to deduplicate a submit and correlate it with
+   * {@link AGENT_CHAT_SUBMIT_RESULT_EVENT}. Auto-generated if omitted.
+   */
+  submitMessageId?: string;
 }
 
 export interface AgentChatContextItem {
@@ -210,6 +215,45 @@ export const AGENT_CHAT_INSERT_REFERENCE_EVENT =
   "agentNative:insert-composer-reference";
 const AGENT_PANEL_PREPARE_EVENT = "agent-panel:prepare";
 
+/**
+ * Fired once a submitted turn's fate is known: `delivered: true` once the
+ * receiving AssistantChat has actually committed the turn (added it to the
+ * visible thread, independent of whether the agent's response later
+ * succeeds), or `delivered: false` when it was rejected before ever
+ * appearing — e.g. no LLM/agent engine configured. Callers that must know
+ * whether their submit truly landed (rather than fire-and-forget) should use
+ * {@link sendToAgentChatAndConfirm} instead of listening for this directly.
+ */
+export const AGENT_CHAT_SUBMIT_RESULT_EVENT = "agentNative.chatSubmitResult";
+
+export interface AgentChatSubmitResult {
+  submitMessageId: string;
+  delivered: boolean;
+  reason?: string;
+}
+
+/** Report a submit's definitive outcome so `sendToAgentChatAndConfirm` (or any
+ * other correlated listener) can resolve. No-ops without a submitMessageId or
+ * a window (SSR). */
+export function reportAgentChatSubmitResult(
+  submitMessageId: string | undefined,
+  delivered: boolean,
+  reason?: string,
+): void {
+  if (
+    !submitMessageId ||
+    cancelledSubmitIds.has(submitMessageId) ||
+    typeof window === "undefined"
+  ) {
+    return;
+  }
+  window.dispatchEvent(
+    new CustomEvent<AgentChatSubmitResult>(AGENT_CHAT_SUBMIT_RESULT_EVENT, {
+      detail: { submitMessageId, delivered, reason },
+    }),
+  );
+}
+
 let agentChatContextState: AgentChatContextState = {
   items: [],
   updatedAt: 0,
@@ -262,6 +306,7 @@ interface BufferedSelfSubmit {
 const SELF_SUBMIT_BUFFER_TTL_MS = 8000;
 const bufferedSelfSubmits: BufferedSelfSubmit[] = [];
 const claimedSubmitIds = new Set<string>();
+const cancelledSubmitIds = new Set<string>();
 
 interface BufferedOpenRequest extends BufferedAgentChatOpenRequest {
   at: number;
@@ -289,6 +334,28 @@ function bufferSelfSubmit(data: Record<string, unknown>): void {
   bufferedSelfSubmits.push({ id, data, at: now });
 }
 
+/**
+ * Permanently tombstone a submit for this page lifetime and remove its
+ * cold-start replay. A confirmation timeout must be terminal: callers may
+ * retry while preserving their own state, so the original submit cannot be
+ * allowed to appear later when a lazy panel or thread ref finally mounts.
+ */
+export function cancelAgentChatSubmit(id: string | undefined): void {
+  if (!id) return;
+  cancelledSubmitIds.add(id);
+  claimedSubmitIds.add(id);
+  for (let index = bufferedSelfSubmits.length - 1; index >= 0; index -= 1) {
+    if (bufferedSelfSubmits[index]?.id === id) {
+      bufferedSelfSubmits.splice(index, 1);
+    }
+  }
+}
+
+/** Whether a confirmed-submit timeout has made this delivery terminal. */
+export function isAgentChatSubmitCancelled(id: string | undefined): boolean {
+  return Boolean(id && cancelledSubmitIds.has(id));
+}
+
 function pruneOpenRequestBuffer(now: number): void {
   for (let i = bufferedOpenRequests.length - 1; i >= 0; i -= 1) {
     if (now - bufferedOpenRequests[i].at > OPEN_REQUEST_BUFFER_TTL_MS) {
@@ -328,6 +395,7 @@ export function drainBufferedAgentChatSubmits(): Array<
 /** Claim a submit; false if already handled. Idless submits always pass. */
 export function claimAgentChatSubmit(id: string | undefined): boolean {
   if (!id) return true;
+  if (cancelledSubmitIds.has(id)) return false;
   if (claimedSubmitIds.has(id)) return false;
   claimedSubmitIds.add(id);
   return true;
@@ -353,6 +421,7 @@ export function claimAgentChatOpenRequest(id: unknown): boolean {
 export function _resetAgentChatSubmitBufferForTests(): void {
   bufferedSelfSubmits.length = 0;
   claimedSubmitIds.clear();
+  cancelledSubmitIds.clear();
   bufferedOpenRequests.length = 0;
   claimedOpenRequestIds.clear();
 }
@@ -896,7 +965,7 @@ export function sendToAgentChat(opts: AgentChatMessage): string {
     return tabId;
   }
 
-  const submitMessageId = generateSubmitMessageId();
+  const submitMessageId = opts.submitMessageId ?? generateSubmitMessageId();
   const payload = {
     type: AGENT_CHAT_MESSAGE_TYPE,
     data: {
@@ -977,6 +1046,101 @@ export function sendToAgentChat(opts: AgentChatMessage): string {
   return tabId;
 }
 
+// Must exceed SELF_SUBMIT_BUFFER_TTL_MS. Otherwise confirmation can time out
+// while its replay is still eligible to mount and deliver later.
+const DEFAULT_SUBMIT_CONFIRM_TIMEOUT_MS = SELF_SUBMIT_BUFFER_TTL_MS + 2000;
+
+export interface SendToAgentChatAndConfirmResult {
+  tabId: string;
+  /** True once the message actually became a visible turn in the chat. */
+  delivered: boolean;
+  /** Set when `delivered` is false: "missing-engine", "timeout", etc. */
+  reason?: string;
+}
+
+/**
+ * Like {@link sendToAgentChat}, but resolves once the submit's fate is known
+ * instead of firing and forgetting. Use this whenever the caller must decide
+ * whether to keep/restore its own state on failure (e.g. a draw/annotate
+ * overlay that should not discard the user's work unless the message actually
+ * reached the chat) — see the `AGENT_CHAT_SUBMIT_RESULT_EVENT` contract.
+ * This acknowledgement is intentionally limited to submitted, non-code
+ * messages with `chatTarget: "local"`; parent-frame and MCP host chats use
+ * different delivery protocols and return `unsupported-target` here.
+ *
+ * Resolves `delivered: false` if the receiving chat explicitly rejects the
+ * submit (e.g. no LLM/agent engine configured) OR if no result arrives within
+ * `timeoutMs` — a silently-stuck submit (panel never mounts, thread never
+ * gets a ref, message type not handled by this build) must fail the same way
+ * an explicit rejection does, since the caller cannot otherwise tell the
+ * difference between "still in flight" and "dropped."
+ */
+export function sendToAgentChatAndConfirm(
+  opts: Omit<AgentChatMessage, "submitMessageId">,
+  options?: { timeoutMs?: number },
+): Promise<SendToAgentChatAndConfirmResult> {
+  const tabId = opts.tabId ?? generateTabId();
+  if (typeof window === "undefined") {
+    return Promise.resolve({ tabId, delivered: false, reason: "no-window" });
+  }
+  // Confirmation is deliberately a same-window/local-chat contract. Parent
+  // frames, Builder code chat, and MCP host relays have independent protocols
+  // and cannot answer this window-local CustomEvent acknowledgement.
+  if (
+    opts.chatTarget !== "local" ||
+    opts.type === "code" ||
+    opts.requiresCode === true ||
+    opts.submit === false
+  ) {
+    return Promise.resolve({
+      tabId,
+      delivered: false,
+      reason: "unsupported-target",
+    });
+  }
+
+  const submitMessageId = generateSubmitMessageId();
+  const timeoutMs = Math.max(
+    0,
+    options?.timeoutMs ?? DEFAULT_SUBMIT_CONFIRM_TIMEOUT_MS,
+  );
+
+  return new Promise<SendToAgentChatAndConfirmResult>((resolve) => {
+    let settled = false;
+    let timer: number | undefined;
+    const cleanup = () => {
+      window.removeEventListener(
+        AGENT_CHAT_SUBMIT_RESULT_EVENT,
+        onResult as EventListener,
+      );
+      if (timer !== undefined) window.clearTimeout(timer);
+    };
+    const finish = (delivered: boolean, reason?: string, cancel = false) => {
+      if (settled) return;
+      settled = true;
+      if (cancel) cancelAgentChatSubmit(submitMessageId);
+      cleanup();
+      resolve({ tabId, delivered, reason });
+    };
+    const onResult = (event: Event) => {
+      const detail = (event as CustomEvent<AgentChatSubmitResult>).detail;
+      if (!detail || detail.submitMessageId !== submitMessageId) return;
+      finish(detail.delivered, detail.reason);
+    };
+
+    window.addEventListener(
+      AGENT_CHAT_SUBMIT_RESULT_EVENT,
+      onResult as EventListener,
+    );
+    timer = window.setTimeout(() => finish(false, "timeout", true), timeoutMs);
+    try {
+      sendToAgentChat({ ...opts, tabId, submitMessageId });
+    } catch {
+      finish(false, "send-failed", true);
+    }
+  });
+}
+
 /**
  * Add or replace a keyed context nugget in the active agent chat composer.
  * The context is not submitted until the user sends the prompt.

package/corpus/core/src/client/chat/index.ts

@@ -59,7 +59,15 @@ export {
 } from "../code-agent-chat-adapter.js";
 export * from "./connectors.js";
 export * from "./runtime.js";
-export { sendToAgentChat, type AgentChatMessage } from "../agent-chat.js";
+export {
+  sendToAgentChat,
+  sendToAgentChatAndConfirm,
+  reportAgentChatSubmitResult,
+  AGENT_CHAT_SUBMIT_RESULT_EVENT,
+  type AgentChatMessage,
+  type AgentChatSubmitResult,
+  type SendToAgentChatAndConfirmResult,
+} from "../agent-chat.js";
 export { useAgentChatGenerating } from "../use-agent-chat.js";
 export { useSendToAgentChat } from "../use-send-to-agent-chat.js";
 export {

package/corpus/core/src/client/extensions/EmbeddedExtension.tsx

@@ -85,6 +85,31 @@ function serializeChatValue(value: unknown): string | undefined {
   }
 }
 
+/**
+ * Slot contexts (e.g. Design's `DesignExtensionSlotContext`) commonly carry
+ * live callback functions alongside plain data — the host component uses
+ * those callbacks itself, but `window.postMessage` uses the structured clone
+ * algorithm, which throws a `DataCloneError` on any function-valued property
+ * (see MDN's postMessage docs). Round-tripping through JSON drops functions
+ * (and other non-cloneable values like symbols) the same way
+ * `JSON.stringify` already silently omits them, producing a payload that's
+ * safe to post. Exported so a test can verify functions never reach the
+ * iframe instead of only reading the code.
+ */
+export function sanitizeSlotContextForPostMessage(
+  context: Record<string, unknown> | null | undefined,
+): Record<string, unknown> {
+  try {
+    return JSON.parse(JSON.stringify(context ?? {}));
+  } catch {
+    // Circular reference or other non-serializable shape — fail safe to an
+    // empty context rather than letting postMessage throw and skip every
+    // other message this handler sends in the same tick (theme update,
+    // ready signal).
+    return {};
+  }
+}
+
 export interface EmbeddedExtensionProps {
   extensionId: string;
   /** Slot identifier passed via the iframe URL so the extension runtime knows it's
@@ -243,8 +268,16 @@ export function EmbeddedExtension({
   useEffect(() => {
     const win = iframeRef.current?.contentWindow;
     if (!win) return;
+    // Post the JSON-round-tripped context, not the raw `context` object —
+    // slot contexts (e.g. Design's DesignExtensionSlotContext) carry live
+    // callback functions the host uses internally, and postMessage's
+    // structured clone throws a DataCloneError on any function-valued
+    // property. See sanitizeSlotContextForPostMessage's docblock.
     win.postMessage(
-      { type: "agent-native-slot-context", context: context ?? {} },
+      {
+        type: "agent-native-slot-context",
+        context: sanitizeSlotContextForPostMessage(context),
+      },
       "*",
     );
   }, [contextJson]);
@@ -400,7 +433,10 @@ export function EmbeddedExtension({
         style={{ width: "100%", border: 0, height, display: "block" }}
         onLoad={() => {
           iframeRef.current?.contentWindow?.postMessage(
-            { type: "agent-native-slot-context", context: context ?? {} },
+            {
+              type: "agent-native-slot-context",
+              context: sanitizeSlotContextForPostMessage(context),
+            },
             "*",
           );
           // Re-assert theme once the iframe document is live. The src bakes in

package/corpus/core/src/client/index.ts

@@ -19,6 +19,9 @@ export {
   requestAgentChatThreadOpen,
   requestAgentTaskOpen,
   sendToAgentChat,
+  sendToAgentChatAndConfirm,
+  reportAgentChatSubmitResult,
+  AGENT_CHAT_SUBMIT_RESULT_EVENT,
   parseSubmitChatMessage,
   setAgentChatContextItem,
   setContextToAgentChat,
@@ -33,6 +36,8 @@ export {
   type AgentChatContextSetOptions,
   type AgentChatContextState,
   type AgentChatMessage,
+  type AgentChatSubmitResult,
+  type SendToAgentChatAndConfirmResult,
   type AgentComposerReference,
   type AgentComposerReferenceInsertOptions,
   type AgentComposerReferenceInsertPayload,

package/corpus/core/src/client/rich-markdown-editor/useCollabReconcile.ts

@@ -385,6 +385,8 @@ export function useCollabReconcile({
       const editorUnchangedSinceApply =
         lastAppliedSerializedRef.current !== null &&
         currentMarkdown === lastAppliedSerializedRef.current;
+      const typingRecently =
+        editor.isFocused && Date.now() - lastTypedAtRef.current < 1500;
 
       // Doc-equivalence skip. Never re-apply content the editor already
       // represents — comparing by DOC EQUIVALENCE, not raw strings/timestamps:
@@ -407,11 +409,15 @@ export function useCollabReconcile({
       //      `<p>` → `&lt;p&gt;` → `&amp;lt;p&amp;gt;` escalation.
       if (
         currentMarkdown === normalizedValue ||
-        value === lastEmittedRef.current ||
-        // A stale-but-recent echo of our own (possibly partial) save — applying
-        // it would clobber the freshly-typed tail. External edits never match.
-        recentEmittedRef.current.includes(value) ||
-        recentEmittedRef.current.includes(normalizedValue) ||
+        (typingRecently &&
+          // A stale echo of our own (possibly partial) save while the user is
+          // actively typing would clobber the fresh tail. Outside active
+          // typing, the same bytes can be a deliberate newer external revert
+          // (history restore / provider conflict choice) and must be allowed
+          // through even if mount-time normalization emitted them.
+          (value === lastEmittedRef.current ||
+            recentEmittedRef.current.includes(value) ||
+            recentEmittedRef.current.includes(normalizedValue))) ||
         (editorUnchangedSinceApply &&
           (value === lastAppliedValueRef.current ||
             normalizedValue === lastAppliedSerializedRef.current))
@@ -442,8 +448,6 @@ export function useCollabReconcile({
       // for non-idempotent input, fight every keystroke. Newer external content
       // retries so it still lands once they pause; older-or-equal content is a
       // stale poll and is dropped outright while focused.
-      const typingRecently =
-        editor.isFocused && Date.now() - lastTypedAtRef.current < 1500;
       if (typingRecently) {
         if (externalNewer) {
           retry = setTimeout(() => apply(deferred), 700);
@@ -549,6 +553,13 @@ export function useCollabReconcile({
 
   const shouldIgnoreUpdate = (transaction: Transaction): boolean => {
     if (!editable || isSettingContentRef.current) return true;
+    // Collaboration can emit schema/default-paragraph transactions while the
+    // persisted Y.Doc is still loading and before the authoritative value has
+    // seeded/reconciled. Never let those transient pre-seed updates reach an
+    // app's local mirror or autosave path (Content serializes an empty paragraph
+    // as `<empty-block/>`, which is non-empty text and bypasses the generic
+    // registerEmitted empty-string guard).
+    if (collab && !seededRef.current) return true;
     if (transaction.getMeta(RICH_MARKDOWN_PROGRAMMATIC_TRANSACTION)) {
       return true;
     }

package/corpus/core/src/collab/awareness-store.ts

@@ -149,23 +149,34 @@ export async function loadAwarenessRows(
   now: number = Date.now(),
 ): Promise<AwarenessEntry[]> {
   try {
-    await ensureTable();
-    const client = getDbExec();
-    const { rows } = await client.execute({
-      sql: `SELECT client_id, state, last_seen FROM _collab_awareness
-            WHERE doc_id = ? AND last_seen >= ?`,
-      args: [docId, now - ROW_TTL_MS],
-    });
-    return rows.map((row: any) => ({
-      clientId: Number(row.client_id),
-      state: String(row.state),
-      lastSeen: Number(row.last_seen),
-    }));
+    return await loadAwarenessRowsStrict(docId, now);
   } catch {
     return [];
   }
 }
 
+/**
+ * Strict awareness read for safety-critical callers that must distinguish
+ * "no active participants" from "presence storage could not be read."
+ */
+export async function loadAwarenessRowsStrict(
+  docId: string,
+  now: number = Date.now(),
+): Promise<AwarenessEntry[]> {
+  await ensureTable();
+  const client = getDbExec();
+  const { rows } = await client.execute({
+    sql: `SELECT client_id, state, last_seen FROM _collab_awareness
+          WHERE doc_id = ? AND last_seen >= ?`,
+    args: [docId, now - ROW_TTL_MS],
+  });
+  return rows.map((row: any) => ({
+    clientId: Number(row.client_id),
+    state: String(row.state),
+    lastSeen: Number(row.last_seen),
+  }));
+}
+
 async function maybePurge(docId: string, now: number): Promise<void> {
   const last = _lastPurges.get(docId) ?? 0;
   if (now - last < PURGE_INTERVAL_MS) return;