@agent-native/core 0.108.0 → 0.109.1

package/corpus/core/src/client/chat/tool-call-display.tsx

@@ -63,6 +63,8 @@ import {
 
 // Exported so AssistantChatInner can provide a context value.
 export const ChatRunningContext = React.createContext(false);
+export const ChatRunDurationContext = React.createContext<number | null>(null);
+export const ASSISTANT_VISIBLE_TOOL_CALL_LIMIT = 3;
 
 /**
  * Human-in-the-loop approval bridge. `AssistantChatInner` provides a value that
@@ -898,6 +900,7 @@ export function ReconnectStreamMessage({
   content: ContentPart[];
 }) {
   const chatRunning = React.useContext(ChatRunningContext);
+  const toolSummary = getReconnectToolSummaryInfo(content);
   const latestReasoningPartIndex = content.reduce(
     (latestIndex, part, index) =>
       part.type === "reasoning" ? index : latestIndex,
@@ -908,61 +911,148 @@ export function ReconnectStreamMessage({
   const streamingReasoningPartIndex =
     content.at(-1)?.type === "reasoning" ? content.length - 1 : -1;
 
+  const renderPart = (part: ContentPart, i: number) => {
+    if (part.type === "text") {
+      const partStreaming = chatRunning && i === streamingTextPartIndex;
+      return (
+        <SmoothMarkdownText
+          key={`reconnect-text-${i}`}
+          text={part.text}
+          streaming={partStreaming}
+          resetKey={`reconnect-text-${i}`}
+          statusType={partStreaming ? "running" : "complete"}
+        />
+      );
+    }
+    if (part.type === "reasoning") {
+      return (
+        <ReasoningCell
+          key={`reconnect-reasoning-${i}`}
+          text={part.text}
+          isStreaming={chatRunning && i === streamingReasoningPartIndex}
+          resetKey={`reconnect-reasoning-${i}`}
+          defaultOpen={i === latestReasoningPartIndex}
+          collapseWhenReplaced={i < latestReasoningPartIndex}
+        />
+      );
+    }
+    return (
+      <ToolCallDisplay
+        key={`reconnect-tool-${i}`}
+        toolName={part.toolName}
+        argsText={part.argsText}
+        args={part.args}
+        result={part.result}
+        mcpApp={part.mcpApp}
+        chatUI={part.chatUI}
+        structuredMeta={part.structuredMeta}
+        isRunning={
+          part.result === undefined && (chatRunning || part.activity === true)
+        }
+        approval={part.approval}
+        repeatCount={part.repeatCount}
+      />
+    );
+  };
+
+  const renderedParts: React.ReactNode[] = [];
+  let summaryStartIndex = -1;
+  let summaryToolCount = 0;
+  const flushSummary = (endIndex: number) => {
+    if (summaryStartIndex < 0) return;
+    renderedParts.push(
+      <RanToolsSummary
+        key={`reconnect-tool-summary-${summaryStartIndex}`}
+        toolCount={summaryToolCount}
+      >
+        {content
+          .slice(summaryStartIndex, endIndex)
+          .map((part, offset) => renderPart(part, summaryStartIndex + offset))}
+      </RanToolsSummary>,
+    );
+    summaryStartIndex = -1;
+    summaryToolCount = 0;
+  };
+
+  for (let i = 0; i < content.length; i++) {
+    const part = content[i]!;
+    const isOlderToolWork =
+      toolSummary.startIndex >= 0 &&
+      i < toolSummary.startIndex &&
+      isReconnectToolSummaryPart(content, i, toolSummary.startIndex);
+    if (isOlderToolWork) {
+      summaryStartIndex = summaryStartIndex < 0 ? i : summaryStartIndex;
+      if (part.type === "tool-call") summaryToolCount++;
+      continue;
+    }
+    flushSummary(i);
+    renderedParts.push(renderPart(part, i));
+  }
+  flushSummary(content.length);
+
   return (
     <div className="flex justify-start">
       <div className="w-full max-w-[95%] text-sm leading-relaxed text-foreground space-y-1">
-        {content.map((part, i) => {
-          if (part.type === "text") {
-            const partStreaming = chatRunning && i === streamingTextPartIndex;
-            return (
-              <SmoothMarkdownText
-                key={`reconnect-text-${i}`}
-                text={part.text}
-                streaming={partStreaming}
-                resetKey={`reconnect-text-${i}`}
-                statusType={partStreaming ? "running" : "complete"}
-              />
-            );
-          }
-          if (part.type === "reasoning") {
-            return (
-              <ReasoningCell
-                key={`reconnect-reasoning-${i}`}
-                text={part.text}
-                isStreaming={chatRunning && i === streamingReasoningPartIndex}
-                resetKey={`reconnect-reasoning-${i}`}
-                defaultOpen={i === latestReasoningPartIndex}
-                collapseWhenReplaced={i < latestReasoningPartIndex}
-              />
-            );
-          }
-          if (part.type === "tool-call") {
-            return (
-              <ToolCallDisplay
-                key={`reconnect-tool-${i}`}
-                toolName={part.toolName}
-                argsText={part.argsText}
-                args={part.args}
-                result={part.result}
-                mcpApp={part.mcpApp}
-                chatUI={part.chatUI}
-                structuredMeta={part.structuredMeta}
-                isRunning={
-                  part.result === undefined &&
-                  (chatRunning || part.activity === true)
-                }
-                approval={part.approval}
-                repeatCount={part.repeatCount}
-              />
-            );
-          }
-          return null;
-        })}
+        {renderedParts}
       </div>
     </div>
   );
 }
 
+function getReconnectToolSummaryInfo(content: readonly ContentPart[]) {
+  const toolCallIndices = content.reduce<number[]>((indices, part, index) => {
+    if (part.type === "tool-call" && isReconnectSummarizablePart(part)) {
+      indices.push(index);
+    }
+    return indices;
+  }, []);
+  if (toolCallIndices.length <= ASSISTANT_VISIBLE_TOOL_CALL_LIMIT) {
+    return { startIndex: -1 };
+  }
+  return {
+    startIndex:
+      toolCallIndices[
+        toolCallIndices.length - ASSISTANT_VISIBLE_TOOL_CALL_LIMIT
+      ]!,
+  };
+}
+
+function isReconnectSummarizablePart(part: ContentPart): boolean {
+  return (
+    part.type === "reasoning" ||
+    (part.type === "tool-call" && part.toolName !== "connect-builder")
+  );
+}
+
+function isReconnectToolSummaryPart(
+  content: readonly ContentPart[],
+  index: number,
+  startIndex: number,
+): boolean {
+  if (startIndex < 0 || index >= startIndex) return false;
+  if (!isReconnectSummarizablePart(content[index]!)) return false;
+
+  let segmentStart = index;
+  while (
+    segmentStart > 0 &&
+    isReconnectSummarizablePart(content[segmentStart - 1]!)
+  ) {
+    segmentStart--;
+  }
+
+  let segmentEnd = index + 1;
+  while (
+    segmentEnd < startIndex &&
+    isReconnectSummarizablePart(content[segmentEnd]!)
+  ) {
+    segmentEnd++;
+  }
+
+  return content
+    .slice(segmentStart, segmentEnd)
+    .some((candidate) => candidate.type === "tool-call");
+}
+
 // ─── Reasoning / Thinking cell ────────────────────────────────────────────────
 
 /**
@@ -1141,6 +1231,39 @@ export function WorkedForSummary({
   );
 }
 
+export function RanToolsSummary({
+  toolCount,
+  children,
+}: {
+  toolCount: number;
+  children: React.ReactNode;
+}) {
+  const [open, setOpen] = useState(false);
+  const label = `Ran ${toolCount} ${toolCount === 1 ? "tool" : "tools"}`;
+
+  return (
+    <div className="my-1 w-full">
+      <button
+        type="button"
+        onClick={() => setOpen((v) => !v)}
+        aria-expanded={open}
+        className="flex items-center gap-1.5 py-0.5 text-[13px] text-muted-foreground transition-colors hover:text-foreground"
+      >
+        <span>{label}</span>
+        <IconChevronRight
+          className={cn(
+            "size-3.5 shrink-0 transition-transform",
+            open && "rotate-90",
+          )}
+        />
+      </button>
+      <AnimatedCollapse open={open}>
+        <div className="pt-1">{children}</div>
+      </AnimatedCollapse>
+    </div>
+  );
+}
+
 // ─── Re-export for AssistantMessage ───────────────────────────────────────────
 // AssistantMessage in AssistantChat.tsx uses FilesChangedSummary directly, so
 // re-export it so AssistantChat.tsx can import from one place.

package/corpus/core/src/client/chat/use-agent-chat-lifecycle-tracking.ts

@@ -0,0 +1,74 @@
+import { useCallback, useEffect } from "react";
+
+import {
+  ACTIVE_RUN_STATE_EVENT,
+  getActiveRun,
+  type ActiveRunState,
+} from "../active-run-state.js";
+import { trackAgentChatLifecycle } from "../analytics.js";
+
+export interface AgentChatLifecycleTrackingOptions {
+  surface: string;
+  threadId?: string;
+  tabId?: string;
+  onActiveRunChange?: (active: boolean) => void;
+}
+
+export function useAgentChatLifecycleTracking({
+  surface,
+  threadId,
+  tabId,
+  onActiveRunChange,
+}: AgentChatLifecycleTrackingOptions): (runId?: string) => void {
+  useEffect(() => {
+    trackAgentChatLifecycle({
+      phase: "surface-mounted",
+      surface,
+      ...(threadId ? { threadId } : {}),
+      ...(tabId ? { tabId } : {}),
+    });
+  }, [surface, tabId, threadId]);
+
+  useEffect(() => {
+    const sync = (state = getActiveRun()) => {
+      const active = Boolean(
+        threadId && state?.threadId === threadId && state.runId,
+      );
+      onActiveRunChange?.(active);
+      if (!active || !state) return;
+      trackAgentChatLifecycle({
+        phase: "run-observed",
+        surface,
+        threadId: state.threadId,
+        runId: state.runId,
+        ...(tabId ? { tabId } : {}),
+      });
+    };
+    sync();
+    const activeRunHandler = (event: Event) => {
+      const state = (event as CustomEvent<{ state?: ActiveRunState | null }>)
+        .detail?.state;
+      sync(state ?? null);
+    };
+    const storageHandler = () => sync();
+    window.addEventListener(ACTIVE_RUN_STATE_EVENT, activeRunHandler);
+    window.addEventListener("storage", storageHandler);
+    return () => {
+      window.removeEventListener(ACTIVE_RUN_STATE_EVENT, activeRunHandler);
+      window.removeEventListener("storage", storageHandler);
+    };
+  }, [onActiveRunChange, surface, tabId, threadId]);
+
+  return useCallback(
+    (runId?: string) => {
+      trackAgentChatLifecycle({
+        phase: "run-stopped",
+        surface,
+        ...(threadId ? { threadId } : {}),
+        ...(runId ? { runId } : {}),
+        ...(tabId ? { tabId } : {}),
+      });
+    },
+    [surface, tabId, threadId],
+  );
+}

package/corpus/core/src/client/chat-thread-url.ts

@@ -0,0 +1,11 @@
+export function hasChatThreadDeepLink(): boolean {
+  if (typeof window === "undefined") return false;
+  try {
+    const params = new URLSearchParams(window.location.search);
+    return Boolean(
+      params.get("thread")?.trim() || params.get("threadId")?.trim(),
+    );
+  } catch {
+    return false;
+  }
+}

package/corpus/core/src/client/error-capture.ts

@@ -355,6 +355,18 @@ function shouldIgnoreAutoCapturedError(normalized: {
     return true;
   }
 
+  // Route-chunk recovery reloads the current page after stale lazy chunks or
+  // module scripts fail. Browser-level failures have no useful stack, so do
+  // not retain the transient loader noise as an application issue.
+  if (
+    !stack &&
+    /^(?:Importing a module script failed\.?|(?:Failed to fetch|error loading) dynamically imported module(?::.*)?)$/i.test(
+      message,
+    )
+  ) {
+    return true;
+  }
+
   if (
     normalized.type === "InvalidStateError" &&
     /^Transition was aborted because of invalid state$/i.test(message)

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

@@ -1,6 +1,6 @@
 import { IconPlus } from "@tabler/icons-react";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
-import { useState } from "react";
+import { useEffect, useRef, useState } from "react";
 
 import { sendToAgentChat } from "../agent-chat.js";
 import { agentNativePath } from "../api-path.js";
@@ -49,6 +49,8 @@ export interface ExtensionSlotProps {
   className?: string;
   /** Optional className applied to each EmbeddedExtension. */
   toolClassName?: string;
+  /** Fires once when the slot query and all installed extensions are ready. */
+  onReady?: () => void;
 }
 
 /**
@@ -70,8 +72,11 @@ export function ExtensionSlot({
   showEmptyAffordance,
   className,
   toolClassName,
+  onReady,
 }: ExtensionSlotProps) {
   const t = useT();
+  const readyInstallIds = useRef(new Set<string>());
+  const readyNotified = useRef(false);
   const installsQuery = useQuery<SlotInstall[]>({
     queryKey: ["slot-installs", id],
     queryFn: async () => {
@@ -87,6 +92,35 @@ export function ExtensionSlot({
   });
   const installs = installsQuery.data ?? [];
 
+  useEffect(() => {
+    readyInstallIds.current.clear();
+    readyNotified.current = false;
+  }, [id]);
+
+  useEffect(() => {
+    if (readyNotified.current || installsQuery.isLoading) return;
+    if (
+      installsQuery.isError ||
+      installs.length === 0 ||
+      readyInstallIds.current.size >= installs.length
+    ) {
+      readyNotified.current = true;
+      onReady?.();
+    }
+  }, [installs, installsQuery.isError, installsQuery.isLoading, onReady]);
+
+  const markInstallReady = (installId: string) => {
+    readyInstallIds.current.add(installId);
+    if (
+      !readyNotified.current &&
+      !installsQuery.isLoading &&
+      readyInstallIds.current.size >= installs.length
+    ) {
+      readyNotified.current = true;
+      onReady?.();
+    }
+  };
+
   if (installsQuery.isLoading) {
     return null;
   }
@@ -121,6 +155,8 @@ export function ExtensionSlot({
           slotId={id}
           context={context}
           className={toolClassName}
+          onReady={() => markInstallReady(install.installId)}
+          onUnavailable={() => markInstallReady(install.installId)}
         />
       ))}
     </div>

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

@@ -787,6 +787,7 @@ export {
 export { AgentTerminal, type AgentTerminalProps } from "./terminal/index.js";
 export {
   trackEvent,
+  trackAgentChatLifecycle,
   trackSessionStatus,
   configureTracking,
   setTrackingContentCaptureEnabled,
@@ -811,6 +812,7 @@ export {
   type CaptureExceptionContext,
   type CapturedExceptionEvent,
   type ClientCaptureContext,
+  type AgentChatLifecycleEvent,
   type ConfigureTrackingOptions,
   type ErrorCaptureConfigOptions,
   type ExceptionBreadcrumb,

package/corpus/core/src/client/route-chunk-recovery.ts

@@ -201,6 +201,17 @@ function recoverToIntendedNavigation(
   return true;
 }
 
+function recoverFromDynamicImportFailure(
+  win: Window,
+  state: RouteChunkRecoveryState,
+  message: string,
+): boolean {
+  if (!isDynamicImportFailureMessage(message)) return false;
+  state.routeModuleFailureAt = Date.now();
+  if (recoverToIntendedNavigation(win, state)) return true;
+  return reloadForStaleChunk(win);
+}
+
 function patchHistoryMethod(
   win: Window,
   state: RouteChunkRecoveryState,
@@ -290,16 +301,17 @@ export function installRouteChunkRecovery(
   win.addEventListener("unhandledrejection", (event) => {
     const reason = (event as PromiseRejectionEvent).reason;
     const message = String(reason?.message || reason || "");
-    if (!isDynamicImportFailureMessage(message)) return;
-    state.routeModuleFailureAt = Date.now();
-    if (recoverToIntendedNavigation(win, state)) {
+    if (recoverFromDynamicImportFailure(win, state, message)) {
       event.preventDefault();
-      return;
     }
-    // No fresh cross-route target — the current route's own chunk went stale.
-    // Reload once (guarded) to fetch fresh assets instead of leaving the user
-    // on a broken view.
-    if (reloadForStaleChunk(win)) {
+  });
+
+  win.addEventListener("error", (event) => {
+    const errorEvent = event as ErrorEvent;
+    const message = String(
+      errorEvent.error?.message || errorEvent.message || "",
+    );
+    if (recoverFromDynamicImportFailure(win, state, message)) {
       event.preventDefault();
     }
   });

package/corpus/core/src/client/session-replay.ts

@@ -390,6 +390,8 @@ const SESSION_REPLAY_CLAIM_TIMEOUT_MS = 150;
 export const SESSION_REPLAY_CONSOLE_EVENT_TAG = "agent-native.console";
 /** rrweb custom-event tag for captured fetch/XHR request summaries. */
 export const SESSION_REPLAY_NETWORK_EVENT_TAG = "agent-native.network";
+/** Content-free agent-chat lifecycle markers for replay incident forensics. */
+export const SESSION_REPLAY_AGENT_CHAT_EVENT_TAG = "agent-native.chat";
 
 const DEFAULT_MAX_CONSOLE_EVENTS = 1000;
 const DEFAULT_MAX_NETWORK_EVENTS = 2000;
@@ -3384,3 +3386,32 @@ export function emitSessionReplayException(input: {
     ...(input.url ? { url: input.url } : {}),
   });
 }
+
+export type SessionReplayAgentChatEvent = {
+  phase: "surface-mounted" | "run-observed" | "run-stopped";
+  surface: string;
+  threadId?: string;
+  runId?: string;
+  tabId?: string;
+};
+
+/**
+ * Add a content-free chat lifecycle marker to the active replay. The payload
+ * deliberately accepts only ids and low-cardinality state; prompt/response
+ * content must never enter replay diagnostics through this path.
+ */
+export function emitSessionReplayAgentChatEvent(
+  input: SessionReplayAgentChatEvent,
+): void {
+  const state = getState();
+  if (!state.active || !state.addCustomEvent) return;
+  const bounded = (value: string | undefined, max = 160) =>
+    value?.trim().slice(0, max) || undefined;
+  emitReplayCustomEvent(state, SESSION_REPLAY_AGENT_CHAT_EVENT_TAG, {
+    phase: input.phase,
+    surface: bounded(input.surface, 80) ?? "app",
+    ...(bounded(input.threadId) ? { threadId: bounded(input.threadId) } : {}),
+    ...(bounded(input.runId) ? { runId: bounded(input.runId) } : {}),
+    ...(bounded(input.tabId) ? { tabId: bounded(input.tabId) } : {}),
+  });
+}

package/corpus/core/src/client/use-run-stuck-detection.ts

@@ -80,6 +80,7 @@ export const DEFAULT_BACKGROUND_STUCK_THRESHOLD_MS = 180_000;
 export const DEFAULT_LIVE_BACKGROUND_STUCK_THRESHOLD_MS = 13 * 60_000;
 const DEFAULT_POLL_INTERVAL_MS = 5_000;
 const IDLE_BACKOFF_INTERVAL_MS = 15_000;
+const MAX_POLL_ERROR_BACKOFF_MS = 30_000;
 const FRESH_BACKGROUND_HEARTBEAT_MS = 30_000;
 
 interface ActiveRunResponse {
@@ -129,6 +130,22 @@ export function useRunStuckDetection({
     let timer: ReturnType<typeof setTimeout> | null = null;
     let snapshotTransitionTimer: ReturnType<typeof setTimeout> | null = null;
     let snapshotVersion = 0;
+    let consecutivePollFailures = 0;
+
+    const pollFailureDelay = () => {
+      consecutivePollFailures += 1;
+      return Math.min(
+        Math.max(pollIntervalMs, 1) * 2 ** consecutivePollFailures,
+        MAX_POLL_ERROR_BACKOFF_MS,
+      );
+    };
+
+    const clearObservedRun = () => {
+      snapshotVersion += 1;
+      if (snapshotTransitionTimer) clearTimeout(snapshotTransitionTimer);
+      snapshotTransitionTimer = null;
+      setState(EMPTY_STATE);
+    };
 
     type RunHealthSnapshot = {
       active: boolean;
@@ -269,6 +286,7 @@ export function useRunStuckDetection({
         );
         if (cancelled) return;
         if (res.ok) {
+          consecutivePollFailures = 0;
           const data = (await res.json()) as ActiveRunResponse;
           const lastProgressAt = data.lastProgressAt ?? null;
           // Measure elapsed against the SERVER clock (serverNow) rather than the
@@ -336,9 +354,17 @@ export function useRunStuckDetection({
           if (!data.active || data.status !== "running") {
             nextDelay = IDLE_BACKOFF_INTERVAL_MS;
           }
+        } else if (res.status === 429 || res.status >= 500) {
+          nextDelay = pollFailureDelay();
+        } else {
+          consecutivePollFailures = 0;
+          clearObservedRun();
+          nextDelay = MAX_POLL_ERROR_BACKOFF_MS;
         }
       } catch {
-        // Network blip — leave previous state. Next tick will retry.
+        // Network/503 blip — leave previous state and ease polling pressure
+        // while the server or database recovers.
+        nextDelay = pollFailureDelay();
       }
       if (!cancelled) {
         timer = setTimeout(poll, nextDelay);

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

@@ -669,6 +669,61 @@ export function isConnectionError(err: any): boolean {
   );
 }
 
+/**
+ * Classify database failures that should temporarily shed request load.
+ * Statement timeouts are not included in isConnectionError() because retrying
+ * every timed-out mutation would not be safe, but request handlers can still
+ * return a retryable service-unavailable response for them.
+ */
+export function isTransientDatabaseError(err: unknown): boolean {
+  const error = err as {
+    code?: unknown;
+    name?: unknown;
+    message?: unknown;
+    stack?: unknown;
+    cause?: {
+      code?: unknown;
+      name?: unknown;
+      message?: unknown;
+      stack?: unknown;
+    };
+  };
+  const code = String(error?.code ?? error?.cause?.code ?? "");
+  if (
+    code === "ECHECKOUTTIMEOUT" ||
+    code === "53300" ||
+    code === "57014" ||
+    /^08/.test(code) ||
+    /^57P0[123]$/.test(code)
+  ) {
+    return true;
+  }
+
+  const message = [error?.message, error?.cause?.message]
+    .filter((value): value is string => typeof value === "string")
+    .join(" ");
+  if (
+    /\bstatement timeout\b|\bdb (?:query|connect) timed out\b/i.test(message)
+  ) {
+    return true;
+  }
+
+  const databaseSurface = [
+    error?.name,
+    error?.cause?.name,
+    error?.stack,
+    error?.cause?.stack,
+  ]
+    .filter((value): value is string => typeof value === "string")
+    .join(" ");
+  return (
+    isConnectionError(error) &&
+    /@neondatabase|@libsql|\bpostgres(?:ql)?\b|\bpg-pool\b|drizzle-orm|\/db\/client\.[cm]?[jt]s/i.test(
+      databaseSurface,
+    )
+  );
+}
+
 export async function retryOnConnectionError<T>(
   fn: () => Promise<T>,
   maxAttempts = 3,

package/corpus/core/src/extensions/actions.ts

@@ -727,20 +727,8 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
           !coerceBoolean(args?.allowFullReplacement)
         ) {
           const message =
-            "Full extension-body replacement was blocked to preserve the existing visual design. Read the current extension and use focused patches/edits for a data-only repair. Only retry with allowFullReplacement=true when the user explicitly requested a broad visual rewrite or supplied a complete replacement body.";
-          throw new AgentActionStopError(message, {
-            errorCode: "extension_full_replacement_requires_explicit_intent",
-            toolResult: JSON.stringify(
-              {
-                error: "extension_full_replacement_requires_explicit_intent",
-                message,
-                recoverable: false,
-                next: "Call get-extension once, then update-extension with patches or edits that change only the data-loading code. Use allowFullReplacement=true only for an explicitly requested visual rewrite.",
-              },
-              null,
-              2,
-            ),
-          });
+            "Full extension-body replacement requires allowFullReplacement=true. No changes were applied. If the user's request includes a broad visual rewrite such as changing layout, compactness, visible sections, naming, or padding, retry once with allowFullReplacement=true; otherwise read the current extension and use focused patches/edits for a data-only repair. Do not retry unchanged arguments.";
+          throw new ExtensionContentEditError(message);
         }
 
         // Full-replacement content can come inline (`content`) or by reference

package/corpus/core/src/extensions/store.ts

@@ -1192,7 +1192,7 @@ export async function updateExtensionContent(
 
   if (opts.content !== undefined && opts.allowFullReplacement !== true) {
     throw new ExtensionContentEditError(
-      "Full extension-body replacement requires explicit allowFullReplacement=true. Use patches or edits for a targeted data-only repair so the existing design is preserved.",
+      "Full extension-body replacement requires allowFullReplacement=true. No changes were applied. Use patches or edits for a targeted data-only repair, or set allowFullReplacement=true for a user-requested broad visual rewrite.",
     );
   }