@agent-native/core 0.91.2 → 0.92.1

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

@@ -3,6 +3,7 @@ import type { ActionRunContext } from "../action.js";
 import type { ActionEntry } from "../agent/production-agent.js";
 import type { AgentChatAttachment } from "../agent/types.js";
 import { writeAppState } from "../application-state/script-helpers.js";
+import { getRequestRunContext } from "../server/request-context.js";
 import { resolveAccess } from "../sharing/access.js";
 import type {
   ExtensionContentEdit,
@@ -38,6 +39,8 @@ import {
   unhideExtension,
   updateExtension,
   updateExtensionContent,
+  type ExtensionHistoryDetail,
+  type ExtensionHistoryEntry,
   type ExtensionRow,
 } from "./store.js";
 
@@ -126,7 +129,7 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
     "get-extension": {
       tool: {
         description:
-          "Get one existing extension by id. Use this when <current-screen> or <current-url> contains extensionId for the current extension; do not call list-extensions just to rediscover that id. Defaults to including the full Alpine.js content so you can make a targeted update-extension edit.",
+          "Get one existing extension by id. Use this when <current-screen> or <current-url> contains extensionId for the current extension; do not call list-extensions just to rediscover that id. Defaults to including the full Alpine.js content once per run so you can make a targeted update-extension edit; repeated unchanged reads return compact metadata unless forceContent=true.",
         parameters: {
           type: "object",
           properties: {
@@ -140,6 +143,11 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
               description:
                 "Include full Alpine.js content. Defaults to true for targeted edits.",
             },
+            forceContent: {
+              type: "boolean",
+              description:
+                "Return full content even if this run already read the same unchanged body. Use sparingly; prefer update-extension edits after the first read.",
+            },
           },
           required: ["id"],
         },
@@ -151,14 +159,16 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
           args?.includeContent === undefined
             ? true
             : coerceBoolean(args.includeContent);
+        const forceContent = coerceBoolean(args?.forceContent);
         const localExtension = await getLocalExtension(id);
         if (localExtension) {
           return {
             ok: true,
-            extension: await summarizeExtension(
+            extension: await summarizeExtensionForAgentRead(
               localExtension,
               new Set(),
               includeContent,
+              forceContent,
             ),
           };
         }
@@ -167,10 +177,11 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
         const hiddenIds = await getHiddenExtensionIdsForCurrentUser();
         return {
           ok: true,
-          extension: await summarizeExtension(
+          extension: await summarizeExtensionForAgentRead(
             extension,
             hiddenIds,
             includeContent,
+            forceContent,
           ),
         };
       },
@@ -223,7 +234,7 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
     "get-extension-history-version": {
       tool: {
         description:
-          "Get one extension history version with its previous-version diff. Use after list-extension-history when the user wants to inspect exactly what changed.",
+          "Get one extension history version with its previous-version diff. Use after list-extension-history when the user wants to inspect exactly what changed. Full HTML bodies are omitted by default; set includeContent=true only when restoring or manually comparing full source.",
         parameters: {
           type: "object",
           properties: {
@@ -235,6 +246,11 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
               type: "number",
               description: "History version number to inspect.",
             },
+            includeContent: {
+              type: "boolean",
+              description:
+                "Include full HTML for the current and previous versions. Defaults to false to keep agent context compact.",
+            },
           },
           required: ["id", "version"],
         },
@@ -252,7 +268,13 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
         if (!detail) {
           return `Error: extension history version not found: ${id}#${version}`;
         }
-        return { ok: true, ...detail };
+        return {
+          ok: true,
+          ...compactExtensionHistoryDetail(
+            detail,
+            coerceBoolean(args?.includeContent),
+          ),
+        };
       },
       readOnly: true,
     },
@@ -1059,11 +1081,97 @@ async function summarizeExtension(
     hiddenBy: row.hiddenBy,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt,
+    contentLength: row.content.length,
+    contentHash: contentFingerprint(row.content),
     ...(local ? { source: row.source } : {}),
     ...(includeContent ? { content: row.content } : {}),
   };
 }
 
+async function summarizeExtensionForAgentRead(
+  row: ExtensionRow | LocalExtensionRow,
+  hiddenIds: Set<string>,
+  includeContent: boolean,
+  forceContent: boolean,
+) {
+  if (!includeContent) {
+    return summarizeExtension(row, hiddenIds, false);
+  }
+
+  const fingerprint = contentFingerprint(row.content);
+  const runCtx = getRequestRunContext();
+  const reads = runCtx ? (runCtx.extensionContentReads ??= {}) : undefined;
+  const alreadySent = !forceContent && reads?.[row.id] === fingerprint;
+  if (!alreadySent && reads) {
+    reads[row.id] = fingerprint;
+  }
+
+  const summary = await summarizeExtension(row, hiddenIds, !alreadySent);
+  if (!alreadySent) return summary;
+
+  return {
+    ...summary,
+    contentOmitted: {
+      reason: "unchanged-content-already-returned-this-run",
+      contentHash: fingerprint,
+      contentLength: row.content.length,
+      next: "Use the content already returned earlier in this run and call update-extension with focused edits/patches. Set forceContent=true only if you truly need the full body again.",
+    },
+  };
+}
+
+function compactExtensionHistoryDetail(
+  detail: ExtensionHistoryDetail,
+  includeContent: boolean,
+): ExtensionHistoryDetail & {
+  diffOmitted?: { omittedLines: number; maxLines: number };
+} {
+  const diffMaxLines = 400;
+  const fullDiff = detail.diff ?? [];
+  const diff =
+    fullDiff.length > diffMaxLines
+      ? [...fullDiff.slice(0, 200), ...fullDiff.slice(fullDiff.length - 200)]
+      : fullDiff;
+  return {
+    ...detail,
+    entry: compactHistoryEntry(detail.entry, includeContent),
+    previous: detail.previous
+      ? compactHistoryEntry(detail.previous, includeContent)
+      : null,
+    diff,
+    ...(fullDiff.length > diff.length
+      ? {
+          diffOmitted: {
+            omittedLines: fullDiff.length - diff.length,
+            maxLines: diffMaxLines,
+          },
+        }
+      : {}),
+  };
+}
+
+function compactHistoryEntry(
+  entry: ExtensionHistoryEntry,
+  includeContent: boolean,
+): ExtensionHistoryEntry & { contentHash?: string } {
+  const content = entry.content ?? "";
+  const withHash = {
+    ...entry,
+    ...(content ? { contentHash: contentFingerprint(content) } : {}),
+  };
+  if (includeContent) return withHash;
+  const { content: _content, ...withoutContent } = withHash;
+  return withoutContent;
+}
+
+function contentFingerprint(content: string): string {
+  let hash = 5381;
+  for (let i = 0; i < content.length; i++) {
+    hash = (hash * 33) ^ content.charCodeAt(i);
+  }
+  return `${content.length.toString(36)}-${(hash >>> 0).toString(36)}`;
+}
+
 async function localExtensionEditMessage(id: string): Promise<string | null> {
   const localExtension = await getLocalExtension(id);
   if (!localExtension) return null;

package/corpus/core/src/extensions/html-shell.ts

@@ -24,10 +24,11 @@ export const EXTENSION_IFRAME_META_CSP = EXTENSION_IFRAME_CSP_BASE;
  *
  *   1. The iframe MUST be rendered with a `sandbox` attribute that does NOT
  *      include `allow-same-origin`. The viewer (`ExtensionViewer.tsx`,
- *      `EmbeddedExtension.tsx`) sets `sandbox="allow-scripts allow-forms"` —
- *      and that is the only acceptable shape. Adding `allow-same-origin`
- *      would give the extension full DOM access to the parent window via
- *      cross-frame script.
+ *      `EmbeddedExtension.tsx`) normalizes the sandbox through
+ *      `normalizeAgentNativeExtensionSandbox()`, which permits scripts, forms,
+ *      popups, and downloads but strips `allow-same-origin`. Adding
+ *      `allow-same-origin` would give the extension full DOM access to the
+ *      parent window via cross-frame script.
  *
  *   2. Every reachable parent action must treat the postMessage payload as
  *      hostile. The bridge in `iframe-bridge.ts` enforces a path allowlist,

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

@@ -107,6 +107,8 @@ export function createExtensionsHandler() {
   });
 }
 
+const MAX_EXTENSION_DATA_BYTES = 1024 * 1024;
+
 function normalizeExtensionUserEmail(email: string): string {
   return email.trim().toLowerCase();
 }
@@ -544,6 +546,14 @@ async function handleExtensionDataUpsert(
   const itemId = String(body.id || randomUUID());
   const data =
     typeof body.data === "string" ? body.data : JSON.stringify(body.data);
+  if (Buffer.byteLength(data, "utf8") > MAX_EXTENSION_DATA_BYTES) {
+    setResponseStatus(event, 413);
+    return {
+      error:
+        "Extension data is too large for SQL storage. Store large files, base64, or blobs in file storage and save only a URL or handle.",
+      maxBytes: MAX_EXTENSION_DATA_BYTES,
+    };
+  }
   const now = new Date().toISOString();
   const scope = body.scope === "org" ? "org" : "user";
   const orgId = getRequestOrgId();

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

@@ -15,7 +15,7 @@ export const STANDARD_SETTINGS_TABS = {
   providers: "providers",
   connections: "connections",
   secrets: "secrets",
-  team: "team",
+  team: "organization",
   usage: "usage",
   language: "language",
   whatsNew: "whats-new",

package/corpus/core/src/notifications/channels.ts

@@ -1,17 +1,22 @@
 /**
  * Built-in notification channels.
  *
- * Set environment variables to auto-register the webhook channel at startup.
+ * Webhook and Slack are always registered. Delivery uses (in order):
+ *   1. per-notification `metadata.webhookUrl` / `metadata.slackWebhookUrl`
+ *   2. the matching `NOTIFICATIONS_*` env URL (workspace default)
+ * If neither is set, that channel no-ops for the emission.
+ *
  * Extra channels can be registered at any time via
  * `registerNotificationChannel()` from a server plugin.
  *
- * NOTIFICATIONS_WEBHOOK_URL  → POST notifications as JSON to this URL.
+ * NOTIFICATIONS_WEBHOOK_URL  → default POST JSON URL when metadata omits one.
  *                              Supports `${keys.NAME}` substitution — the raw
  *                              value never enters the agent context.
  * NOTIFICATIONS_WEBHOOK_AUTH → optional `Authorization` header value (also
  *                              supports `${keys.NAME}`).
  * NOTIFICATIONS_SLACK_WEBHOOK_URL
- *                            → POST notifications to a Slack incoming webhook.
+ *                            → default Slack incoming webhook when metadata
+ *                              omits `slackWebhookUrl`.
  *                              Supports `${keys.NAME}` substitution.
  * NOTIFICATIONS_EMAIL_CHANNEL=1
  *                            → enable the built-in email channel for
@@ -30,7 +35,7 @@ import {
 } from "../secrets/substitution.js";
 import { sendEmail } from "../server/email.js";
 import { registerNotificationChannel } from "./registry.js";
-import type { NotificationChannel } from "./types.js";
+import type { NotificationChannel, NotificationInput } from "./types.js";
 
 let _registered = false;
 
@@ -38,30 +43,38 @@ export function registerBuiltinNotificationChannels(): void {
   if (_registered) return;
   _registered = true;
 
-  const url = process.env.NOTIFICATIONS_WEBHOOK_URL;
-  if (url) {
-    registerNotificationChannel(createWebhookChannel(url));
-  }
-
-  const slackUrl = process.env.NOTIFICATIONS_SLACK_WEBHOOK_URL;
-  if (slackUrl) {
-    registerNotificationChannel(createSlackWebhookChannel(slackUrl));
-  }
-
-  const emailRecipients = process.env.NOTIFICATIONS_EMAIL_RECIPIENTS?.trim();
-  if (process.env.NOTIFICATIONS_EMAIL_CHANNEL === "1" || emailRecipients) {
-    registerNotificationChannel(createEmailChannel());
-  }
+  registerNotificationChannel(
+    createWebhookChannel(process.env.NOTIFICATIONS_WEBHOOK_URL),
+  );
+  registerNotificationChannel(
+    createSlackWebhookChannel(process.env.NOTIFICATIONS_SLACK_WEBHOOK_URL),
+  );
+  // Email is always registered so per-notification `metadata.emailRecipients`
+  // work without a workspace-wide env flag (same pattern as webhook/slack).
+  registerNotificationChannel(createEmailChannel());
 }
 
-function createWebhookChannel(urlTemplate: string): NotificationChannel {
+function createWebhookChannel(
+  envUrlTemplate: string | undefined,
+): NotificationChannel {
   const authTemplate = process.env.NOTIFICATIONS_WEBHOOK_AUTH;
   return {
     name: "webhook",
     async deliver(input, meta) {
+      const overrideUrlTemplate = deliveryMetadataString(
+        input.metadata,
+        "webhookUrl",
+      );
+      const urlTemplate =
+        overrideUrlTemplate ??
+        metadataString(input.metadata, "webhookUrl") ??
+        envUrlTemplate?.trim();
+      // No-op when neither a per-notification nor workspace URL is set —
+      // mirrors email's empty-recipients behavior so notify-all stays quiet.
+      if (!urlTemplate) return false;
       const { url, headers } = await resolveWebhookRequest(
         urlTemplate,
-        authTemplate,
+        overrideUrlTemplate ? undefined : authTemplate,
         meta.owner,
         "webhook",
       );
@@ -74,7 +87,7 @@ function createWebhookChannel(urlTemplate: string): NotificationChannel {
             severity: input.severity,
             title: input.title,
             body: input.body,
-            metadata: input.metadata,
+            metadata: scrubDeliveryMetadata(input.metadata),
             owner: meta.owner,
             emittedAt: new Date().toISOString(),
           }),
@@ -92,14 +105,25 @@ function createWebhookChannel(urlTemplate: string): NotificationChannel {
   };
 }
 
-function createSlackWebhookChannel(urlTemplate: string): NotificationChannel {
+function createSlackWebhookChannel(
+  envUrlTemplate: string | undefined,
+): NotificationChannel {
   const authTemplate = process.env.NOTIFICATIONS_SLACK_WEBHOOK_AUTH;
   return {
     name: "slack",
     async deliver(input, meta) {
+      const overrideUrlTemplate = deliveryMetadataString(
+        input.metadata,
+        "slackWebhookUrl",
+      );
+      const urlTemplate =
+        overrideUrlTemplate ??
+        metadataString(input.metadata, "slackWebhookUrl") ??
+        envUrlTemplate?.trim();
+      if (!urlTemplate) return false;
       const { url, headers } = await resolveWebhookRequest(
         urlTemplate,
-        authTemplate,
+        overrideUrlTemplate ? undefined : authTemplate,
         meta.owner,
         "Slack webhook",
       );
@@ -159,7 +183,7 @@ function createEmailChannel(): NotificationChannel {
     name: "email",
     async deliver(input) {
       const recipients = notificationEmailRecipients(input.metadata);
-      if (recipients.length === 0) return;
+      if (recipients.length === 0) return false;
       const subject =
         typeof input.metadata?.emailSubject === "string" &&
         input.metadata.emailSubject.trim()
@@ -240,6 +264,41 @@ async function resolveWebhookRequest(
   return { url, headers };
 }
 
+function metadataString(
+  metadata: NotificationInput["metadata"],
+  key: string,
+): string | undefined {
+  const value = metadata?.[key];
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  return trimmed || undefined;
+}
+
+function deliveryMetadataString(
+  metadata: NotificationInput["metadata"],
+  key: string,
+): string | undefined {
+  const delivery = metadata?.delivery;
+  if (!delivery || typeof delivery !== "object" || Array.isArray(delivery)) {
+    return undefined;
+  }
+  const value = (delivery as Record<string, unknown>)[key];
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  return trimmed || undefined;
+}
+
+function scrubDeliveryMetadata(
+  metadata: Record<string, unknown> | undefined,
+): Record<string, unknown> | undefined {
+  if (!metadata) return undefined;
+  const entries = Object.entries(metadata).filter(
+    ([key]) =>
+      key !== "delivery" && key !== "webhookUrl" && key !== "slackWebhookUrl",
+  );
+  return entries.length ? Object.fromEntries(entries) : undefined;
+}
+
 function notificationEmailRecipients(
   metadata: Record<string, unknown> | undefined,
 ): string[] {
@@ -275,7 +334,11 @@ function scrubEmailMetadata(
 ): Record<string, unknown> | null {
   if (!metadata) return null;
   const entries = Object.entries(metadata).filter(
-    ([key]) => key !== "emailRecipients" && key !== "emailSubject",
+    ([key]) =>
+      key !== "emailRecipients" &&
+      key !== "emailSubject" &&
+      key !== "webhookUrl" &&
+      key !== "slackWebhookUrl",
   );
   return entries.length ? Object.fromEntries(entries) : null;
 }

package/corpus/core/src/notifications/registry.ts

@@ -105,6 +105,7 @@ export async function notifyWithDelivery(
     body: truncate(input.body, MAX_BODY_LEN),
   };
   const channels = selectChannels(input.channels);
+  const storedMetadata = scrubStoredMetadata(input.metadata);
 
   // The inbox channel is always included unless explicitly excluded.
   const runInbox = !input.channels || input.channels.includes("inbox");
@@ -120,7 +121,7 @@ export async function notifyWithDelivery(
         severity: input.severity,
         title: input.title,
         body: input.body,
-        metadata: input.metadata,
+        metadata: storedMetadata,
         deliveredChannels: ["inbox"],
       });
       delivered.push("inbox");
@@ -132,13 +133,15 @@ export async function notifyWithDelivery(
   // Await every channel so a 500-ing webhook doesn't end up in `delivered`.
   const results = await Promise.allSettled(
     channels.map(async (channel) => {
-      await channel.deliver(input, meta);
+      const delivered = await channel.deliver(input, meta);
+      // Explicit `false` means the channel skipped (no URL / recipients).
+      if (delivered === false) return null;
       return channel.name;
     }),
   );
   results.forEach((r, i) => {
     if (r.status === "fulfilled") {
-      delivered.push(r.value);
+      if (r.value) delivered.push(r.value);
     } else {
       console.error(
         `[notifications] channel "${channels[i].name}" failed:`,
@@ -181,6 +184,17 @@ export async function notifyWithDelivery(
   return { notification: stored, deliveredChannels: delivered };
 }
 
+function scrubStoredMetadata(
+  metadata: Record<string, unknown> | undefined,
+): Record<string, unknown> | undefined {
+  if (!metadata) return undefined;
+  const entries = Object.entries(metadata).filter(
+    ([key]) =>
+      key !== "delivery" && key !== "webhookUrl" && key !== "slackWebhookUrl",
+  );
+  return entries.length ? Object.fromEntries(entries) : undefined;
+}
+
 function selectChannels(allowlist?: string[]): NotificationChannel[] {
   const registry = getRegistry();
   const all = Array.from(registry.values());

package/corpus/core/src/notifications/types.ts

@@ -41,9 +41,12 @@ export interface NotificationChannel {
   /**
    * Deliver the notification. Must be best-effort — throwing will be logged
    * but will not block other channels from running.
+   *
+   * Return `false` to skip (e.g. no URL / no recipients configured) so the
+   * channel is not recorded in `deliveredChannels`.
    */
   deliver(
     input: NotificationInput,
     meta: NotificationMeta,
-  ): void | Promise<void>;
+  ): void | boolean | Promise<void | boolean>;
 }

package/corpus/core/src/resources/handlers.ts

@@ -607,10 +607,9 @@ export async function handleUploadResource(event: any) {
   }
   const owner = await resolveOwner(event, shared);
 
-  // Prefer a registered file upload provider (e.g. Builder.io) for binary
-  // assets so we get a real CDN URL instead of a base64 blob in SQL.
-  // Text resources still live in SQL — they're edited inline and benefit
-  // from the resource store's metadata/search features.
+  // Binary assets must live in file storage so resource rows do not become
+  // base64 blobs in SQL. Text resources still live in SQL because they are
+  // edited inline and benefit from the resource store's metadata/search.
   const isText =
     mimeType.startsWith("text/") || mimeType === "application/json";
 
@@ -638,12 +637,15 @@ export async function handleUploadResource(event: any) {
       setResponseStatus(event, 201);
       return { ...resource, url: uploaded.url, provider: uploaded.provider };
     }
+    setResponseStatus(event, 503);
+    return {
+      error:
+        "File storage is not configured. Connect Builder.io or register an S3/R2/GCS file upload provider before uploading binary resources.",
+      storageSetupRequired: true,
+    };
   }
 
-  // Fallback: store contents in SQL (base64 for binary, text as-is).
-  const content = isText
-    ? Buffer.from(filePart.data).toString("utf-8")
-    : Buffer.from(filePart.data).toString("base64");
+  const content = Buffer.from(filePart.data).toString("utf-8");
 
   const resource = await resourcePut(owner, path, content, mimeType);
 

package/corpus/core/src/server/agent-chat-plugin.ts

@@ -2739,7 +2739,11 @@ export interface AgentChatPluginOptions {
    * agent starts with only these tools plus `tool-search`; the live registry
    * remains searchable, and matching schemas from `tool-search` results are
    * loaded into the next model request. Use this for domain-focused apps that
-   * have a few common actions and many rare framework utilities.
+   * have a few common actions and many rare framework utilities. Common
+   * provider/corpus/code-execution tools are promoted automatically when present
+   * in the current app/mode registry, so broad integration guidance stays
+   * immediately callable without overloading apps that do not expose those
+   * tools.
    */
   initialToolNames?: string[];
   /**
@@ -3127,7 +3131,7 @@ Keep \`create-extension\` payloads compact enough to finish quickly. For complex
 
 Generated UI content can use appAction(), appFetch(), dbQuery(), extensionFetch(), extensionData, agentNative.ui.output(value, opts?), and agentNative.chat.send(...)/sendToAgentChat(...). Use appAction() for app data writes, and dbQuery() only for read-only inspection of known app SQL tables. It can receive chat inputs through slotContext/window.onSlotContext. Use agentNative.ui.output for passive current values from knobs, sliders, selections, and controls; it writes application state at \`inline-ui:<extensionId>:output\` scoped to the inline extension id returned by \`render-inline-extension\` or \`show-extension-inline\`. When the user later says "use that value", "apply the current setting", or similar, read it with \`readAppState("inline-ui:<id>:output")\` instead of asking them to send it again. Use agentNative.chat.send for visible submit/apply actions that should put a message into chat. Transient extensionData is browser-local and not agent-readable, synced, promoted, or garbage-collected; use application_state/appFetch, appAction, ui.output, or chat.send for anything the agent or app must observe. Use semantic Tailwind classes like bg-background, text-foreground, bg-primary, border-border, and text-muted-foreground so the UI inherits the parent app theme.
 
-If the user asks to change, edit, fix, style, rename, or add behavior to an existing extension/widget/dashboard/calculator/mini-app, use the current extension id from \`<current-screen>\` or \`<current-url>\` when present. Call \`get-extension\` only if you need to inspect its content, then \`update-extension\` with that id. Use \`list-extensions\` only when no current id/name is available. Existing extension edits are SQL data updates, not source-code changes, even when the request says "change the UI" or "fix this". Do **NOT** call \`connect-builder\` for existing extension edits.
+If the user asks to change, edit, fix, style, rename, or add behavior to an existing extension/widget/dashboard/calculator/mini-app, use the current extension id from \`<current-screen>\` or \`<current-url>\` when present. Call \`get-extension\` only if you need to inspect its content, then \`update-extension\` with that id. After one content read, keep the body in working memory and move to focused \`update-extension\` \`edits\`/\`patches\`; do not loop on repeated \`get-extension\` + \`run-code\` string scans before writing. Use \`list-extensions\` only when no current id/name is available. Existing extension edits are SQL data updates, not source-code changes, even when the request says "change the UI" or "fix this". Do **NOT** call \`connect-builder\` for existing extension edits.
 
 In Act mode, when in doubt — if the request asks for a new small interactive utility and does not need reuse, choose \`render-inline-extension\`; if it mentions saving/reuse or asks for an extension/widget/dashboard/calculator/mini-app, choose \`create-extension\`. If it references an existing one or the current extension page, choose \`update-extension\`. Do **not** preface the call with planning text like "let me build the dashboard…" — just call the right extension action directly.
 
@@ -3165,7 +3169,7 @@ Keep the first \`create-extension\` call compact and working. If the request is
 
 Generated UI can read chat inputs from slotContext/window.onSlotContext, see/update app state through appFetch/appAction, use extensionData, record passive current values through agentNative.ui.output(value, opts?), and send visible results through agentNative.chat.send(...) or sendToAgentChat(...). ui.output writes \`inline-ui:<extensionId>:output\` in application state; when the user asks to use the current slider/selection/value, read \`readAppState("inline-ui:<id>:output")\`. Transient extensionData is browser-local only, so do not rely on it for values the agent or app must observe. Use semantic Tailwind theme classes.
 
-If the user asks to change, edit, fix, style, rename, or add behavior to an existing extension/widget/dashboard/calculator/mini-app, use the current extension id from \`<current-screen>\` or \`<current-url>\` when present. Call \`get-extension\` only if you need to inspect its content, then \`update-extension\` with that id. Use \`list-extensions\` only when no current id/name is available. Existing extension edits are SQL data updates, not source-code changes. Do NOT call \`connect-builder\` for them.
+If the user asks to change, edit, fix, style, rename, or add behavior to an existing extension/widget/dashboard/calculator/mini-app, use the current extension id from \`<current-screen>\` or \`<current-url>\` when present. Call \`get-extension\` only if you need to inspect its content, then \`update-extension\` with that id. After one content read, use focused \`update-extension\` \`edits\`/\`patches\`; do not repeatedly re-read and scan the same HTML with \`run-code\` before writing. Use \`list-extensions\` only when no current id/name is available. Existing extension edits are SQL data updates, not source-code changes. Do NOT call \`connect-builder\` for them.
 
 For existing extensions, use \`get-extension\` or \`update-extension\` directly when \`<current-screen>\` or \`<current-url>\` provides an \`extensionId\`. Use \`list-extensions\` only to browse or resolve an unknown name. Use \`hide-extension\` when the user wants a shared extension removed only from their own view. Do not query the legacy \`tools\` table directly.