@agent-native/core 0.194.0 → 0.195.0-nightly-20260927130129

package/corpus/templates/calendar/actions/create-event.ts

@@ -1,16 +1,31 @@
 import { defineAction } from "@agent-native/core/action";
 import type { ActionRunContext } from "@agent-native/core/action";
 import { emit } from "@agent-native/core/event-bus";
+import {
+  DEFAULT_LOCALE,
+  LOCALIZATION_SETTING_KEY,
+  normalizeLocalizationPreference,
+  resolveLocaleFromRequest,
+  type LocaleCode,
+} from "@agent-native/core/localization";
 import { buildDeepLink, getRequestUserEmail } from "@agent-native/core/server";
+import { getUserSetting } from "@agent-native/core/settings";
 import { track } from "@agent-native/core/tracking";
 import { z } from "zod";
 
+import { getCalendarTimezone } from "../server/lib/calendar-settings.js";
 import {
   prepareZoomMeetingPatch,
   shouldAutoAddGoogleMeet,
 } from "../server/lib/event-video-conferencing.js";
 import * as googleCalendar from "../server/lib/google-calendar.js";
 import type { CalendarEvent } from "../shared/api.js";
+import {
+  addDaysToDateKey,
+  dateKeyInTimezone,
+  isCalendarTimezone,
+} from "../shared/timezone.js";
+import { zoomAddFailedMessages } from "../shared/zoom-add-failed-messages.js";
 import {
   availabilityInput,
   autoDeclineModeInput,
@@ -19,6 +34,7 @@ import {
   buildReminderOverrides,
   buildStatusEventFields,
   cliBoolean,
+  extractVideoLink,
   eventTypeInput,
   googleColorIdInput,
   ensureOrganizerInAttendees,
@@ -34,6 +50,193 @@ import {
   workingLocationTypeInput,
 } from "./event-action-helpers.js";
 
+const DATE_ONLY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const ACTION_CHANGE_TITLE_LIMIT = 180;
+
+function eventTimezone(
+  value: string | undefined,
+  input: string,
+  fallback?: string,
+): string | null {
+  if (isCalendarTimezone(value)) return value;
+  const inputOffset = input.match(/(?:Z|[+-]\d{2}:\d{2})$/i)?.[0];
+  if (inputOffset) {
+    return inputOffset.toUpperCase() === "Z" ? "UTC" : inputOffset;
+  }
+  return isCalendarTimezone(fallback) ? fallback : null;
+}
+
+function eventDate(value: string, timezone: string | null): string | undefined {
+  if (DATE_ONLY_PATTERN.test(value)) return value;
+  const instant = new Date(value);
+  return timezone && !Number.isNaN(instant.getTime())
+    ? dateKeyInTimezone(instant, timezone)
+    : undefined;
+}
+
+function eventTime(
+  value: string,
+  timezone: string,
+  locale: string,
+): string | undefined {
+  const instant = new Date(value);
+  return Number.isNaN(instant.getTime())
+    ? undefined
+    : new Intl.DateTimeFormat(locale, {
+        timeZone: timezone,
+        hour: "numeric",
+        minute: "2-digit",
+      }).format(instant);
+}
+
+function eventTimezoneLabel(timezone: string): string {
+  return /^[+-]\d{2}:\d{2}$/.test(timezone) ? `UTC${timezone}` : timezone;
+}
+
+function localizedDate(value: string, locale: string): string | undefined {
+  if (!DATE_ONLY_PATTERN.test(value)) return undefined;
+  const instant = new Date(`${value}T12:00:00.000Z`);
+  return Number.isNaN(instant.getTime())
+    ? undefined
+    : new Intl.DateTimeFormat(locale, {
+        dateStyle: "medium",
+        timeZone: "UTC",
+      }).format(instant);
+}
+
+async function getActionLocale(
+  email: string,
+  requestHeaders: Headers | undefined,
+): Promise<LocaleCode> {
+  let preference:
+    | ReturnType<typeof normalizeLocalizationPreference>
+    | undefined;
+  try {
+    preference = normalizeLocalizationPreference(
+      await getUserSetting(email, LOCALIZATION_SETTING_KEY),
+    );
+  } catch {
+    // coercion-ok: the saved locale only formats the result card; it cannot block event creation.
+  }
+  return resolveLocaleFromRequest({
+    preference,
+    request: requestHeaders ? { headers: requestHeaders } : undefined,
+    fallback: DEFAULT_LOCALE,
+  }).locale;
+}
+
+function getZoomFailureMessage(locale: LocaleCode): string {
+  return (
+    zoomAddFailedMessages[locale as keyof typeof zoomAddFailedMessages] ??
+    zoomAddFailedMessages[DEFAULT_LOCALE]
+  );
+}
+
+function eventChangeTitle(event: CalendarEvent): string {
+  const location = event.workingLocationProperties;
+  let fallback = "Event";
+  if (location?.type === "homeOffice") fallback = "Home";
+  if (location?.type === "officeLocation") {
+    fallback = location.officeLocation?.label || "Office";
+  }
+  if (location?.type === "customLocation") {
+    fallback = location.customLocation?.label || "Working location";
+  }
+  return (event.title.trim() || fallback.trim() || "Event").slice(
+    0,
+    ACTION_CHANGE_TITLE_LIMIT,
+  );
+}
+
+function eventChangeDetail(
+  event: CalendarEvent,
+  args: { eventType?: string; fullDay?: boolean; start: string; end: string },
+  locale: string,
+  additions: Array<string | undefined> = [],
+  timezoneFallback?: string,
+): string | undefined {
+  const startTimezone = eventTimezone(
+    event.startTimeZone,
+    args.start,
+    timezoneFallback,
+  );
+  const endTimezone = eventTimezone(
+    event.endTimeZone ?? event.startTimeZone,
+    args.end,
+    startTimezone ?? timezoneFallback,
+  );
+  const fullDayOutOfOffice =
+    args.eventType === "outOfOffice" && args.fullDay === true;
+  let when: string | undefined;
+
+  if (
+    fullDayOutOfOffice &&
+    DATE_ONLY_PATTERN.test(args.start) &&
+    DATE_ONLY_PATTERN.test(args.end)
+  ) {
+    const start = localizedDate(args.start, locale);
+    const end = localizedDate(args.end, locale);
+    if (start && end && startTimezone) {
+      when = `${start}${start === end ? "" : `–${end}`} ${eventTimezoneLabel(startTimezone)}`;
+    }
+  } else if (
+    event.allDay ||
+    (DATE_ONLY_PATTERN.test(event.start) && DATE_ONLY_PATTERN.test(event.end))
+  ) {
+    const start = eventDate(event.start, startTimezone);
+    const endExclusive = eventDate(event.end, endTimezone);
+    if (start && endExclusive) {
+      const end = addDaysToDateKey(endExclusive, -1);
+      const localizedStart = localizedDate(start, locale);
+      const localizedEnd = localizedDate(end, locale);
+      if (localizedStart && localizedEnd) {
+        when =
+          start === end ? localizedStart : `${localizedStart}–${localizedEnd}`;
+      }
+    }
+  } else if (startTimezone && endTimezone) {
+    const startDate = eventDate(event.start, startTimezone);
+    const endDate = eventDate(event.end, endTimezone);
+    const startTime = eventTime(event.start, startTimezone, locale);
+    const endTime = eventTime(event.end, endTimezone, locale);
+    if (startDate && endDate && startTime && endTime) {
+      const localizedStart = localizedDate(startDate, locale);
+      const localizedEnd = localizedDate(endDate, locale);
+      if (localizedStart && localizedEnd) {
+        when =
+          startDate === endDate && startTimezone === endTimezone
+            ? `${localizedStart} · ${startTime}–${endTime} ${eventTimezoneLabel(startTimezone)}`
+            : `${localizedStart} ${startTime} ${eventTimezoneLabel(startTimezone)}–${localizedEnd} ${endTime} ${eventTimezoneLabel(endTimezone)}`;
+      }
+    }
+  }
+
+  const detail = [when, ...additions, event.location?.trim()]
+    .filter((value): value is string => Boolean(value))
+    .join(" · ")
+    .slice(0, 500);
+  return detail || undefined;
+}
+
+function eventDeepLink(
+  event: Pick<CalendarEvent, "id" | "start" | "startTimeZone">,
+  timezoneFallback?: string | null,
+): string | undefined {
+  if (!event.id) return undefined;
+  const timezone =
+    timezoneFallback === undefined
+      ? eventTimezone(event.startTimeZone, event.start)
+      : timezoneFallback;
+  return buildDeepLink({
+    app: "calendar",
+    view: "calendar",
+    params: {
+      eventId: event.id,
+      date: eventDate(event.start, timezone),
+    },
+  });
+}
+
 export default defineAction({
   description: "Create a calendar event on Google Calendar",
   schema: z.object({
@@ -148,26 +351,6 @@ export default defineAction({
         "Connected Google account email whose primary calendar receives the event. Required when multiple accounts are connected.",
       ),
   }),
-  chatUI: {
-    renderer: "calendar.event-created",
-    projectResult: (_args, result) => {
-      const event = result as Record<string, unknown>;
-      return {
-        id: event.id,
-        title: event.title,
-        start: event.start,
-        end: event.end,
-        startTimeZone: event.startTimeZone,
-        endTimeZone: event.endTimeZone,
-        allDay: event.allDay,
-        location: event.location,
-        hangoutLink: event.hangoutLink,
-        meetingLink: event.meetingLink,
-        conferenceData: event.conferenceData,
-        videoConferenceError: event.videoConferenceError,
-      };
-    },
-  },
   run: async (args, actionContext?: ActionRunContext) => {
     const email = getRequestUserEmail();
     if (!email) throw new Error("no authenticated user");
@@ -195,6 +378,7 @@ export default defineAction({
       normalizeAttendees(args.attendees),
       acctEmail,
     );
+    const locale = await getActionLocale(email, actionContext?.requestHeaders);
     const reminderFields = buildReminderOverrides({
       reminders: args.reminders,
       reminderMinutes: args.reminderMinutes,
@@ -239,6 +423,7 @@ export default defineAction({
 
     let zoomMeetingLink: string | undefined;
     let videoConferenceError: CalendarEvent["videoConferenceError"];
+    let videoConferenceWarning: string | undefined;
     if (args.addZoom) {
       try {
         const zoom = await prepareZoomMeetingPatch(email, calEvent);
@@ -246,6 +431,7 @@ export default defineAction({
         Object.assign(calEvent, zoom.patch);
       } catch (error) {
         videoConferenceError = "zoom";
+        videoConferenceWarning = getZoomFailureMessage(locale);
         console.error("[create-event] Zoom meeting provisioning failed", error);
       }
     }
@@ -269,6 +455,19 @@ export default defineAction({
     if (videoConferenceError)
       calEvent.videoConferenceError = videoConferenceError;
 
+    let timezoneFallback: string | undefined;
+    if (
+      !calEvent.startTimeZone &&
+      !/(?:Z|[+-]\d{2}:\d{2})$/i.test(args.start) &&
+      !DATE_ONLY_PATTERN.test(args.start)
+    ) {
+      try {
+        timezoneFallback = await getCalendarTimezone(email);
+      } catch {
+        // coercion-ok: this timezone only formats the result card after event creation.
+      }
+    }
+
     try {
       emit(
         "calendar.event.created",
@@ -304,22 +503,55 @@ export default defineAction({
       actionContext,
     );
 
-    return calEvent;
+    const startTimezone = eventTimezone(
+      calEvent.startTimeZone,
+      args.start,
+      timezoneFallback,
+    );
+    const url = eventDeepLink(calEvent, startTimezone);
+    const conferenceLink = calEvent.meetingLink ?? extractVideoLink(calEvent);
+    const detail = eventChangeDetail(
+      calEvent,
+      args,
+      locale,
+      [
+        conferenceLink && !calEvent.location?.includes(conferenceLink)
+          ? conferenceLink
+          : undefined,
+        videoConferenceWarning,
+      ],
+      timezoneFallback,
+    );
+    return {
+      ...calEvent,
+      change: {
+        verb: "created",
+        kind: "calendar-event",
+        title: eventChangeTitle(calEvent),
+        ...(detail ? { detail } : {}),
+        ...(url ? { url } : {}),
+      },
+    };
   },
   link: ({ result }) => {
     if (!result || typeof result !== "object") return null;
-    const evt = result as { id?: string; start?: string };
-    if (!evt.id) return null;
-    const date =
-      typeof evt.start === "string" && evt.start
-        ? evt.start.slice(0, 10)
-        : undefined;
+    const evt = result as {
+      id?: string;
+      start?: string;
+      startTimeZone?: string;
+      change?: { url?: string };
+    };
+    if (!evt.id || !evt.start) return null;
+    const url =
+      evt.change?.url ??
+      eventDeepLink({
+        id: evt.id,
+        start: evt.start,
+        startTimeZone: evt.startTimeZone,
+      });
+    if (!url) return null;
     return {
-      url: buildDeepLink({
-        app: "calendar",
-        view: "calendar",
-        params: { eventId: evt.id, date },
-      }),
+      url,
       label: "Open event in Calendar",
       view: "calendar",
     };

package/corpus/templates/calendar/app/i18n/en-US.ts

@@ -1,3 +1,5 @@
+import { zoomAddFailedMessages } from "../../shared/zoom-add-failed-messages.js";
+
 export default {
   common: {
     connect: "Connect",
@@ -47,11 +49,6 @@ export default {
     noEventId: "No event id provided. Add ?id=<eventId> to the URL.",
     openCalendar: "Open calendar",
   },
-  eventCreation: {
-    created: "Event created",
-    zoomNotAdded: "The event was created, but Zoom could not be added.",
-    openInCalendar: "Open event in Calendar",
-  },
   agentSidebar: {
     emptyState: "Ask me anything about your calendar",
     suggestions: {
@@ -1013,7 +1010,7 @@ export default {
     year: "year",
     zoom: "Zoom",
     zoomAdded: "Zoom added",
-    zoomAddFailed: "Failed to add Zoom",
+    zoomAddFailed: zoomAddFailedMessages["en-US"],
     zoomConnectFailed: "Could not connect Zoom",
     zoomConnectionOpened: "Zoom connection opened",
     zoomNotConfigured: "Zoom OAuth is not configured.",

package/corpus/templates/calendar/app/root.tsx

@@ -42,7 +42,6 @@ import { AppToolkitProvider } from "@/components/ui/toolkit-provider";
 
 import changelog from "../CHANGELOG.md?raw";
 import { i18nCatalog } from "./i18n";
-import "@/lib/register-chat-renderers";
 
 import stylesheet from "./global.css?url";
 configureTracking({

package/corpus/templates/calendar/changelog/2026-09-27-agent-created-events-show-details-and-open-links.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-09-27
+---
+
+Events created by the agent now show their date and time with a direct link to Calendar.

package/corpus/templates/calendar/changelog/2026-09-27-calendar-event-cards-retain-meet-and-zoom-links-show-confere.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-09-27
+---
+
+Calendar event cards retain Meet and Zoom links, show conferencing warnings, and format event times in your selected locale.

package/corpus/templates/calendar/changelog/2026-09-27-calendar-event-cards-show-times-in-the-supplied-offset-or-ca.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-09-27
+---
+
+Calendar event cards show times in the supplied offset or Calendar timezone and keep long working-location labels readable.

package/corpus/templates/calendar/shared/zoom-add-failed-messages.ts

@@ -0,0 +1,13 @@
+export const zoomAddFailedMessages = {
+  "en-US": "Failed to add Zoom",
+  "es-ES": "No se pudo agregar Zoom",
+  "fr-FR": "Échec de l'ajout du Zoom",
+  "de-DE": "Zoom konnte nicht hinzugefügt werden",
+  "pt-BR": "Falha ao adicionar Zoom",
+  "zh-CN": "添加Zoom失败",
+  "zh-TW": "新增Zoom失敗",
+  "ja-JP": "Zoomの追加に失敗しました",
+  "ko-KR": "Zoom를 추가하지 못했습니다.",
+  "hi-IN": "Zoom जोड़ने में विफल",
+  "ar-SA": "فشلت إضافة Zoom",
+} as const;

package/corpus/templates/design/.generated/bridge/editor-chrome.generated.ts

@@ -943,14 +943,106 @@ export const editorChromeBridgeScript: string = `"use strict";
     var editorChromeDocumentObserver = null;
     var editorChromeRootObserver = null;
     var repairingEditorChromeHost = false;
+    var userFocusedElement = null;
+    var trustedFocusIntent = null;
+    var focusTargetSelector = 'a[href], area[href], button, input:not([type="hidden"]), select, textarea, summary, iframe, audio[controls], video[controls], [tabindex], [contenteditable]:not([contenteditable="false"]), [role="button"], [role="link"], [role="switch"], [role="checkbox"], [role="radio"], [role="slider"], [role="spinbutton"], [role="menuitem"], [role="textbox"], [role="combobox"], [role="searchbox"]';
+    function isCanvasFocusTarget(target) {
+      return !!(target && (isEditorTypingTarget(target) || target.matches(focusTargetSelector)));
+    }
+    function getCanvasFocusTarget(event) {
+      var path = event.composedPath();
+      for (var i = 0; i < path.length; i += 1) {
+        var node = path[i];
+        if (!(node instanceof Element)) continue;
+        if (node instanceof HTMLLabelElement && node.control) {
+          return node.control;
+        }
+        if (isCanvasFocusTarget(node)) return node;
+        var closest = node.closest(focusTargetSelector);
+        if (closest) return closest;
+      }
+      return null;
+    }
+    function armTrustedFocusIntent(target, kind) {
+      trustedFocusIntent = {
+        target,
+        kind,
+        expiresAt: Date.now() + 1e3
+      };
+    }
+    function rememberUserFocusedElement(event) {
+      var intent = trustedFocusIntent;
+      var target = getCanvasFocusTarget(event);
+      if (!intent || Date.now() > intent.expiresAt || !target || intent.kind === "pointer" && (intent.target === null || intent.target !== target && !event.composedPath().includes(intent.target) && !intent.target.contains(target) && !target.contains(intent.target))) {
+        trustedFocusIntent = null;
+        userFocusedElement = null;
+        return;
+      }
+      userFocusedElement = target;
+      trustedFocusIntent = null;
+    }
+    function rememberTrustedCanvasInput(event) {
+      if (readOnly || interactionMode || !event.isTrusted) return;
+      var target = event.target;
+      if (target instanceof Node && editorChromeHost?.contains(target)) return;
+      if (event.type === "pointerdown") {
+        var pointerFocusTarget = getCanvasFocusTarget(event);
+        userFocusedElement = null;
+        if (pointerFocusTarget) {
+          var active = document.activeElement;
+          var visited = /* @__PURE__ */ new Set();
+          while (active && !visited.has(active)) {
+            visited.add(active);
+            if (active === pointerFocusTarget || pointerFocusTarget.contains(active)) {
+              userFocusedElement = pointerFocusTarget;
+              break;
+            }
+            active = active.shadowRoot?.activeElement || null;
+          }
+        }
+        trustedFocusIntent = pointerFocusTarget ? {
+          target: pointerFocusTarget,
+          kind: "pointer",
+          expiresAt: Date.now() + 1e3
+        } : null;
+        return;
+      }
+      if (event.type === "keydown") {
+        var keyEvent = event;
+        if (keyEvent.key === "Tab") {
+          armTrustedFocusIntent(null, "tab");
+          var tabIntent = trustedFocusIntent;
+          window.setTimeout(function() {
+            if (trustedFocusIntent === tabIntent) trustedFocusIntent = null;
+          }, 0);
+          window.parent.postMessage(
+            { type: "agent-native:canvas-tab-navigation" },
+            "*"
+          );
+          return;
+        }
+        var active = document.activeElement;
+        if (active instanceof Element && isCanvasFocusTarget(active)) {
+          userFocusedElement = active;
+          if (keyEvent.key === "Enter" || keyEvent.key === " " || keyEvent.key === "Escape" || keyEvent.key.startsWith("Arrow")) {
+            armTrustedFocusIntent(active, "activation");
+          }
+        }
+      }
+    }
     function isCanvasFocusTransferSafe() {
+      if (trustedFocusIntent && Date.now() > trustedFocusIntent.expiresAt) {
+        if (trustedFocusIntent.target === userFocusedElement) {
+          userFocusedElement = null;
+        }
+        trustedFocusIntent = null;
+      }
       if (activeTextEditEl) return false;
       var active = document.activeElement;
       var visited = /* @__PURE__ */ new Set();
-      var focusTargetSelector = 'a[href], area[href], button, input:not([type="hidden"]), select, textarea, summary, iframe, audio[controls], video[controls], [tabindex], [contenteditable]:not([contenteditable="false"]), [role="button"], [role="link"], [role="switch"], [role="checkbox"], [role="radio"], [role="slider"], [role="spinbutton"], [role="menuitem"], [role="textbox"], [role="combobox"], [role="searchbox"]';
       while (active && !visited.has(active)) {
         visited.add(active);
-        if (isEditorTypingTarget(active) || active.closest?.(focusTargetSelector)) {
+        if (userFocusedElement?.isConnected && (active === userFocusedElement || userFocusedElement.contains(active))) {
           return false;
         }
         var shadowActive = active.shadowRoot?.activeElement;
@@ -958,19 +1050,17 @@ export const editorChromeBridgeScript: string = `"use strict";
           active = shadowActive;
           continue;
         }
-        if (active !== document.body && active !== document.documentElement && active.matches?.(":focus-within")) {
-          return false;
-        }
         return true;
       }
       return true;
     }
-    function reportCanvasFocusState() {
+    function reportCanvasFocusState(reason) {
       if (readOnly || interactionMode) return;
       window.parent.postMessage(
         {
           type: "agent-native:canvas-focus-state",
-          focusSafe: isCanvasFocusTransferSafe()
+          focusSafe: isCanvasFocusTransferSafe(),
+          ...reason ? { reason } : {}
         },
         "*"
       );
@@ -12451,7 +12541,9 @@ export const editorChromeBridgeScript: string = `"use strict";
               clientY,
               dragged
             );
-            if (betweenChildren) return betweenChildren;
+            if (betweenChildren && (hit === el.parentElement || isAutoLayoutElement(hit))) {
+              return betweenChildren;
+            }
             return {
               anchor: hit,
               placement: "inside",
@@ -12638,7 +12730,7 @@ export const editorChromeBridgeScript: string = `"use strict";
       var exitedContainer = el.parentElement;
       var receivingContainer = exitedContainer && exitedContainer.parentElement;
       var targetContainer = dropContainerForTarget(target);
-      if (!ignoreTargetAutoLayout && target && exitedContainer && receivingContainer && isContainerDropTarget(exitedContainer) && !isAutoLayoutElement(receivingContainer) && target.anchor?.parentElement !== document.body && (targetContainer === receivingContainer || target?.anchor === receivingContainer) && (pointHit === receivingContainer || !pointHit || pointHit === document.body || pointHit === document.documentElement)) {
+      if (!ignoreTargetAutoLayout && target && exitedContainer && receivingContainer && isContainerDropTarget(exitedContainer) && !isAutoLayoutElement(receivingContainer) && !unnestPromotedBoardRootTarget && (targetContainer === receivingContainer || target?.anchor === receivingContainer) && (pointHit === receivingContainer || !pointHit || pointHit === document.body || pointHit === document.documentElement)) {
         target = {
           ...target,
           anchor: exitedContainer,
@@ -17630,11 +17722,35 @@ export const editorChromeBridgeScript: string = `"use strict";
     ].forEach(function(type) {
       document.addEventListener(type, stopBlockedLayerInteraction, true);
     });
-    document.addEventListener("focusin", reportCanvasFocusState, true);
+    document.addEventListener(
+      "focusin",
+      function(event) {
+        rememberUserFocusedElement(event);
+        reportCanvasFocusState();
+      },
+      true
+    );
+    document.addEventListener("pointerdown", rememberTrustedCanvasInput, true);
+    document.addEventListener("keydown", rememberTrustedCanvasInput, true);
     document.addEventListener(
       "focusout",
-      function() {
-        window.setTimeout(reportCanvasFocusState, 0);
+      function(event) {
+        var blurred = event.target instanceof Element ? event.target : null;
+        window.setTimeout(function() {
+          if (blurred && userFocusedElement && (blurred === userFocusedElement || userFocusedElement.contains(blurred))) {
+            var active = document.activeElement;
+            var visited = /* @__PURE__ */ new Set();
+            while (active && !visited.has(active)) {
+              visited.add(active);
+              if (active === userFocusedElement || userFocusedElement.contains(active)) {
+                break;
+              }
+              active = active.shadowRoot?.activeElement || null;
+            }
+            if (!active || !visited.has(active)) userFocusedElement = null;
+          }
+          reportCanvasFocusState();
+        }, 0);
       },
       true
     );
@@ -18756,7 +18872,14 @@ export const editorChromeBridgeScript: string = `"use strict";
         return;
       }
       if (e.data.type === "agent-native:canvas-focus-state-probe") {
-        reportCanvasFocusState();
+        reportCanvasFocusState(
+          e.data.reason === "route-change" ? "route-change" : void 0
+        );
+        return;
+      }
+      if (e.data.type === "agent-native:canvas-focus-claimed") {
+        userFocusedElement = null;
+        trustedFocusIntent = null;
         return;
       }
       if (e.data.type === "resume-text-edit") {
@@ -18816,6 +18939,10 @@ export const editorChromeBridgeScript: string = `"use strict";
       }
       if (e.data.type === "set-read-only") {
         var nextReadOnly = !!e.data.readOnly;
+        if (nextReadOnly !== readOnly) {
+          userFocusedElement = null;
+          trustedFocusIntent = null;
+        }
         readOnly = nextReadOnly;
         textEditingEnabled = !readOnly && !interactionMode && textEditingEnabledFlag;
         if (readOnly) {
@@ -18837,6 +18964,10 @@ export const editorChromeBridgeScript: string = `"use strict";
       }
       if (e.data.type === "set-interaction-mode") {
         var nextInteractionMode = e.data.interact === true;
+        if (nextInteractionMode !== interactionMode) {
+          userFocusedElement = null;
+          trustedFocusIntent = null;
+        }
         interactionMode = nextInteractionMode;
         if (interactionMode) {
           var releaseSpacePan = bridgeSpaceKeyPressed;