@agent-native/core 0.165.3 → 0.167.0

package/corpus/templates/design/app/pages/design-editor/measure-child-rects.ts

@@ -0,0 +1,83 @@
+export interface FreeformGeometry {
+  container: { width: number; height: number } | null;
+  children: Record<
+    string,
+    { x: number; y: number; width: number; height: number }
+  >;
+}
+
+const NOTHING_MEASURED: FreeformGeometry = { container: null, children: {} };
+
+/**
+ * Container-relative geometry for a node and its direct children, read from
+ * whichever preview iframe actually holds the node — the board and each screen
+ * have their own document, so a single global iframe lookup finds the wrong one.
+ */
+export function measureFreeformGeometry(nodeId: string): FreeformGeometry {
+  if (typeof document === "undefined") return NOTHING_MEASURED;
+  const selector = `[data-agent-native-node-id="${CSS.escape(nodeId)}"]`;
+  const iframes = Array.from(
+    document.querySelectorAll<HTMLIFrameElement>(
+      "iframe[data-design-preview-iframe],iframe[data-screen-iframe-id]",
+    ),
+  );
+  for (const iframe of iframes) {
+    let container: HTMLElement | null = null;
+    try {
+      container =
+        iframe.contentDocument?.querySelector<HTMLElement>(selector) ?? null;
+    } catch {
+      // Cross-origin preview surfaces are not measurable; try the next one.
+      continue;
+    }
+    if (!container) continue;
+    const view = container.ownerDocument.defaultView;
+    const origin = container.getBoundingClientRect();
+    // Absolute offsets resolve against the padding box, but a client rect is
+    // the border box, so a bordered container shifts every child it pins.
+    const borders = view?.getComputedStyle(container);
+    // Client rects are viewport-relative, so a scrolled container reports its
+    // children where they currently sit, not where the content box holds them.
+    const originLeft =
+      origin.left + edgeWidth(borders?.borderLeftWidth) - container.scrollLeft;
+    const originTop =
+      origin.top + edgeWidth(borders?.borderTopWidth) - container.scrollTop;
+    const rects: Record<
+      string,
+      { x: number; y: number; width: number; height: number }
+    > = {};
+    for (const child of Array.from(container.children)) {
+      const childId = child.getAttribute("data-agent-native-node-id");
+      if (!childId) continue;
+      const rect = child.getBoundingClientRect();
+      rects[childId] = {
+        x: rect.left - originLeft,
+        y: rect.top - originTop,
+        width: rect.width,
+        height: rect.height,
+      };
+    }
+    // Own box, in the same box-sizing terms as a width/height declaration on
+    // this element, so writing it back reproduces the rendered size.
+    const own = borders
+      ? {
+          width: Number.parseFloat(borders.width),
+          height: Number.parseFloat(borders.height),
+        }
+      : null;
+    return {
+      container:
+        own && Number.isFinite(own.width) && Number.isFinite(own.height)
+          ? own
+          : null,
+      children: rects,
+    };
+  }
+  return NOTHING_MEASURED;
+}
+
+function edgeWidth(value: string | undefined): number {
+  const parsed = Number.parseFloat(value ?? "");
+  // A missing or non-length border computes to no edge; both mean zero inset.
+  return Number.isFinite(parsed) ? parsed : 0;
+}

package/corpus/templates/design/app/pages/design-editor/paste-placement.ts

@@ -131,3 +131,69 @@ export function resolvePastePlacementForSelection(args: {
   if (!node) return null;
   return resolvePastePlacement(pasteTargetFromCodeLayerNode(node));
 }
+
+export interface PasteSourceAnchor {
+  fileId: string;
+  /**
+   * null when the entries do not share one resolvable parent. Never an empty
+   * array — a caller must not read "unresolved" as "insert at the root here",
+   * because the stored left/top are relative to a parent that is not there.
+   */
+  parentSelectors: string[] | null;
+}
+
+/**
+ * A copied layer's left/top are parent-relative, so a paste that lands
+ * anywhere else reads them in the wrong coordinate space. Null means the
+ * source is unknown — never "the document root".
+ */
+export function resolvePasteSourceAnchor(args: {
+  entries: ReadonlyArray<{ rootNodeId?: string; sourceFileId: string }>;
+  getContent: (fileId: string) => string | undefined;
+}): PasteSourceAnchor | null {
+  const first = args.entries[0];
+  if (!first) return null;
+  if (args.entries.some((entry) => entry.sourceFileId !== first.sourceFileId)) {
+    return null;
+  }
+  const content = args.getContent(first.sourceFileId);
+  if (!content) return null;
+  const projection = buildCodeLayerProjection(content);
+  const unresolved: PasteSourceAnchor = {
+    fileId: first.sourceFileId,
+    parentSelectors: null,
+  };
+  const parentIds = args.entries.map((entry) => {
+    const node = entry.rootNodeId
+      ? projection.nodes.find(
+          (candidate) =>
+            candidate.dataAttributes["data-agent-native-node-id"] ===
+              entry.rootNodeId || candidate.id === entry.rootNodeId,
+        )
+      : undefined;
+    return node?.parentId ?? null;
+  });
+  const [sharedParentId] = parentIds;
+  // Layers copied out of different parents have no common coordinate space, so
+  // forcing them into the first one's parent moves the rest.
+  if (!sharedParentId || parentIds.some((id) => id !== sharedParentId)) {
+    return unresolved;
+  }
+  const parent = projection.nodes.find(
+    (candidate) => candidate.id === sharedParentId,
+  );
+  if (!parent) return unresolved;
+  const parentNodeId = parent.dataAttributes["data-agent-native-node-id"];
+  const parentSelectors = [
+    // A node-id selector is unique by construction; the projection's
+    // class/path aliases can match several siblings, and
+    // insertClonedHtmlLayers fails closed on that ambiguity.
+    parentNodeId
+      ? `[data-agent-native-node-id="${parentNodeId.replace(/["\\]/g, "\\$&")}"]`
+      : null,
+    parent.selector,
+    ...parent.selectors,
+  ].filter((selector): selector is string => Boolean(selector));
+  if (parentSelectors.length === 0) return unresolved;
+  return { fileId: first.sourceFileId, parentSelectors };
+}

package/corpus/templates/design/server/routes/[...page].get.ts

@@ -10,7 +10,6 @@ import {
 } from "@agent-native/core/shared";
 import {
   defineEventHandler,
-  getHeader,
   getQuery,
   getRequestURL,
   setResponseHeader,

package/corpus/templates/design/shared/code-layer.ts

@@ -498,6 +498,17 @@ export interface AutoLayoutEditIntent {
   enabled: boolean;
   direction?: "row" | "column";
   gap?: string;
+  /**
+   * Measured child geometry, container-relative, keyed by stable node id.
+   * Supplied when disabling so children keep their rendered positions and
+   * become freely draggable; without it they re-stack in block flow.
+   */
+  childRects?: Record<
+    string,
+    { x: number; y: number; width: number; height: number }
+  >;
+  /** Rendered size of the container, so it cannot collapse once flow empties. */
+  containerRect?: { width: number; height: number };
 }
 
 /**
@@ -950,17 +961,6 @@ function cssIdent(value: string): string | null {
   return null;
 }
 
-function unquoteHtmlAttributeValue(value: string): string {
-  const trimmed = value.trim();
-  if (
-    (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
-    (trimmed.startsWith("'") && trimmed.endsWith("'"))
-  ) {
-    return trimmed.slice(1, -1);
-  }
-  return trimmed;
-}
-
 function escapeHtmlAttribute(value: string): string {
   return value
     .replace(/&/g, "&amp;")
@@ -1777,18 +1777,6 @@ function utilityToStyleProperty(
   return null;
 }
 
-function classStyleToken(token: string): StyleToken | null {
-  const { utility } = parseClassToken(token);
-  const mapped = utilityToStyleProperty(utility);
-  if (!mapped) return null;
-  const { property, confidence } = mapped;
-  // The legacy value field preserves the original full token (including prefix)
-  // for backward compatibility.  The responsive path uses `breakpointValues`.
-  const value =
-    property === "display" ? (utility === "hidden" ? "none" : utility) : token;
-  return { property, value, token, source: "class", confidence };
-}
-
 function layoutFor(
   element: ParsedElement,
   parent: ParsedElement | undefined,
@@ -3385,43 +3373,6 @@ const FLEX_ITEM_STRIP_PROPS = [
   "order",
 ] as const;
 
-/**
- * Apply display:flex + direction + gap to a raw open-tag string and return it.
- * Only touches the style attribute.
- */
-function addAutoLayoutStyleToOpenTag(
-  openTag: string,
-  element: ParsedElement,
-  html: string,
-  direction: "row" | "column",
-  gap: string,
-): string {
-  const currentStyle = attributeValue(element, "style");
-  let declarations = parseStyleDeclarations(currentStyle);
-  const setOrReplace = (prop: string, val: string) => {
-    const existing = declarations.find((d) => d.property === prop);
-    if (existing) {
-      existing.value = val;
-    } else {
-      declarations.push({ property: prop, value: val });
-    }
-  };
-  setOrReplace("display", "flex");
-  setOrReplace("flex-direction", direction);
-  setOrReplace("gap", gap);
-  const nextStyle = serializeStyleDeclarations(declarations);
-  // We work on a scratch copy relative to element boundaries
-  const attr = getAttribute(element, "style");
-  if (attr) {
-    return `${openTag.slice(0, attr.start - element.start)}${attr.name}="${escapeHtmlAttribute(nextStyle)}"${openTag.slice(attr.end - element.start)}`;
-  }
-  // Insert before closing >
-  const closeChar = openTag.endsWith("/>")
-    ? openTag.length - 2
-    : openTag.length - 1;
-  return `${openTag.slice(0, closeChar)} style="${escapeHtmlAttribute(nextStyle)}"${openTag.slice(closeChar)}`;
-}
-
 /**
  * Strip absolute-positioning properties from a child's inline style, applying
  * the edit directly to the html string at the child element's source spans.
@@ -3889,6 +3840,13 @@ function applyUnwrap(
 /**
  * CONVERT: toggle auto-layout (display:flex) on an existing container.
  */
+/** Whether an existing min-width/min-height already preserves `extent` px. */
+function holdsOpen(value: string, extent: number): boolean {
+  const trimmed = value.trim();
+  if (!/^[\d.]+px$/i.test(trimmed)) return !/^0[a-z%]*$/i.test(trimmed);
+  return Number.parseFloat(trimmed) >= extent;
+}
+
 function applyAutoLayout(
   html: string,
   build: ProjectionBuild,
@@ -3907,21 +3865,113 @@ function applyAutoLayout(
   if (!element) return "conflict";
 
   if (!enabled) {
-    // Turn off auto-layout: set display:block.
+    const childRects = intent.childRects;
+    const hasRects = !!childRects && Object.keys(childRects).length > 0;
     const currentStyle = attributeValue(element, "style");
-    let declarations = parseStyleDeclarations(currentStyle);
-    const displayDecl = declarations.find((d) => d.property === "display");
-    if (displayDecl) {
-      displayDecl.value = "block";
-    } else {
-      declarations.push({ property: "display", value: "block" });
+    const declarations = parseStyleDeclarations(currentStyle);
+    const setOnContainer = (property: string, value: string) => {
+      const existing = declarations.find((d) => d.property === property);
+      if (existing) existing.value = value;
+      else declarations.push({ property, value });
+    };
+    setOnContainer("display", "block");
+    if (hasRects) {
+      // Absolute children resolve against the nearest positioned ancestor, so
+      // a static container would let them escape to the page.
+      const position = declarations.find((d) => d.property === "position");
+      if (!position || position.value === "static") {
+        setOnContainer("position", "relative");
+      }
+      // With every child absolute the content box is empty, so a hug-sized
+      // container collapses and overflow:hidden then hides what we just pinned.
+      const rect = intent.containerRect;
+      if (rect) {
+        for (const [property, value] of [
+          ["min-width", rect.width],
+          ["min-height", rect.height],
+        ] as const) {
+          const existing = declarations.find((d) => d.property === property);
+          // `min-height: 0` is the standard flex idiom and holds nothing open.
+          // Only a px minimum at least as large as the measured extent does.
+          if (existing && !holdsOpen(existing.value, value)) {
+            existing.value = `${Math.round(value)}px`;
+          } else if (!existing) {
+            declarations.push({ property, value: `${Math.round(value)}px` });
+          }
+        }
+      }
+    }
+    let result = replaceOrInsertAttribute(
+      html,
+      element,
+      "style",
+      serializeStyleDeclarations(declarations),
+    );
+    if (!hasRects) {
+      return {
+        content: result,
+        capability: { kind: "style", properties: ["display"], confidence: 0.9 },
+      };
+    }
+
+    const updatedElements = parseHtmlElements(result);
+    const targetAttr = attributeValue(element, "data-agent-native-node-id");
+    const updatedTarget =
+      (targetAttr
+        ? updatedElements.find(
+            (fe) =>
+              attributeValue(fe, "data-agent-native-node-id") === targetAttr,
+          )
+        : undefined) ??
+      updatedElements.find((fe) => fe.start === element.start);
+    if (updatedTarget) {
+      // Reverse order keeps earlier offsets valid as each write shifts the rest.
+      for (const childIndex of [...updatedTarget.childIndexes].reverse()) {
+        const child = updatedElements[childIndex];
+        if (!child) continue;
+        const childId = attributeValue(child, "data-agent-native-node-id");
+        const rect = childId ? childRects[childId] : undefined;
+        if (!rect) continue;
+        const childDecls = parseStyleDeclarations(
+          attributeValue(child, "style"),
+        );
+        const setOnChild = (property: string, value: string) => {
+          const existing = childDecls.find((d) => d.property === property);
+          if (existing) existing.value = value;
+          else childDecls.push({ property, value });
+        };
+        // The measured rect is a border box placed by its margin edge, so a
+        // content-box child would grow by its padding and a margin would shift
+        // it off the position we just measured.
+        setOnChild("box-sizing", "border-box");
+        setOnChild("margin", "0");
+        setOnChild("position", "absolute");
+        setOnChild("left", `${Math.round(rect.x)}px`);
+        setOnChild("top", `${Math.round(rect.y)}px`);
+        setOnChild("width", `${Math.round(rect.width)}px`);
+        setOnChild("height", `${Math.round(rect.height)}px`);
+        result = replaceOrInsertAttribute(
+          result,
+          child,
+          "style",
+          serializeStyleDeclarations(childDecls),
+        );
+      }
     }
-    const nextStyle = serializeStyleDeclarations(declarations);
     return {
-      content: replaceOrInsertAttribute(html, element, "style", nextStyle),
+      content: result,
       capability: {
         kind: "style",
-        properties: ["display"],
+        properties: [
+          "display",
+          "position",
+          "min-width",
+          "min-height",
+          "left",
+          "top",
+          "width",
+          "height",
+        ],
         confidence: 0.9,
       },
     };

package/corpus/templates/design/shared/design-surface-index.ts

@@ -13,7 +13,6 @@
  * See `DESIGN-STUDIO-PLAN.md` §4.2 for rationale.
  */
 
-import type { CodeLayerNode } from "./code-layer";
 import type { DesignCapabilityName } from "./design-source-capabilities";
 import type { DesignSourceType } from "./source-mode";
 

package/corpus/templates/design/shared/pen-path.ts

@@ -683,7 +683,3 @@ function roundCoord(value: number) {
 function samePoint(a: PenPoint, b: PenPoint) {
   return a.x === b.x && a.y === b.y;
 }
-
-function isPenPoint(point: PenPoint | undefined): point is PenPoint {
-  return !!point;
-}

package/corpus/templates/dispatch/.agents/skills/secrets/SKILL.md

@@ -38,7 +38,11 @@ connection exists:
   register a `kind: "oauth"` entry so the shared UI renders Connect and the
   runtime owns status, refresh, and reauthorization.
 - **Deploy- or app-level configuration** - use deployment/runtime
-  configuration, not a per-user secret row.
+  configuration, not a per-user secret row. For a non-secret public setting
+  already represented by `AgentNativeConfig`, put the default in
+  `agent-native.config.ts` and use its `AGENT_NATIVE_CONFIG_<PATH>` alias only
+  for a deployment override. Never put a credential or provider key in that
+  public namespace.
 - **Account, customer, manager, or other non-secret identifier** - store it as
   scoped connection metadata or app data, not as a masked secret field.
 

package/corpus/templates/dispatch/.agents/skills/workspace-conventions/SKILL.md

@@ -55,7 +55,10 @@ Preview before `--apply`, commit `agent-native.ejections.json`, and never edit
   ZIPs, screenshots, thumbnails, session replay chunks) in configured file/blob
   storage and persist only URLs, ids, or handles.
 - Store shared runtime configuration in the workspace root `.env`; use
-  `apps/<app>/.env` only for app-specific overrides. Never hardcode API keys,
+  `apps/<app>/.env` only for app-specific overrides. For public app behavior,
+  prefer the default in `agent-native.config.ts` and use the deterministic
+  `AGENT_NATIVE_CONFIG_<UPPER_SNAKE_PATH>` alias only when a non-secret value
+  needs a deployment override. Never hardcode API keys,
   tokens, webhook URLs, signing secrets, private Builder/internal data, customer
   data, or credential-looking literals in source, docs, prompts, fixtures,
   application state, action responses, or generated app content. Use

package/corpus/templates/dispatch/CHANGELOG.md

@@ -3,8 +3,6 @@
 All notable user-facing changes to Agent-Native Dispatch are documented here. Open it any
 time from the command menu (Cmd+K → "What's new").
 
-Older updates live in [the changelog folder](./changelog/) and are included in the in-app "What's new" view.
-
 ## 2026-08-20
 
 ### Fixed
@@ -57,3 +55,199 @@ Older updates live in [the changelog folder](./changelog/) and are included in t
 ### Added
 
 - Chat-first navigation keeps conversations central while opening workspace apps and watched sessions beside them.
+
+## 2026-08-07
+
+### Changed
+
+- Language selection now lives in Settings instead of the Dispatch header.
+
+## 2026-08-06
+
+### Improved
+
+- Dispatch keeps everyday navigation focused while management tools live in a dedicated Admin area
+- Ready workspace apps stay one click away in a compact Dispatch navigation rail
+
+### Security
+
+- Shared Vault values and management are now restricted to workspace owners and admins
+
+## 2026-08-05
+
+### Fixed
+
+- Transactional email catalogs and delivery activity are available in Dispatch again.
+
+## 2026-08-04
+
+### Improved
+
+- Dispatch keeps connected chats out of local history by default and lets you show all sources on demand.
+
+## 2026-08-03
+
+### Improved
+
+- Automation details now show scheduler checks, past runs, and actionable failure diagnostics
+
+## 2026-07-30
+
+### Improved
+
+- Delegated Dispatch work can now continue reliably in the background.
+- Thread Debug now lists recent failed agent runs across connected workspace apps for one-click inspection.
+
+## 2026-07-29
+
+### Added
+
+- Browser chat can securely connect the Agent-Native Chrome extension to Dispatch with page context.
+
+### Fixed
+
+- Workspace members without admin access now see a clear permission message when opening usage metrics.
+
+## 2026-07-28
+
+### Improved
+
+- Pending apps are hidden by default and app ownership details are available from the overflow menu
+
+## 2026-07-27
+
+### Improved
+
+- Creating an app from a curated template now uses clearer, more direct language.
+- Thread Debug can open a run directly from the copied request ID in an Agent Native chat.
+
+## 2026-07-26
+
+### Fixed
+
+- Slack replies now recover after a connected app finishes an update, without repeating the update or losing the delivered reply from future thread context.
+
+## 2026-07-25
+
+### Improved
+
+- App branding now uses the product name without the Agent-Native prefix.
+- Settings navigation now keeps Manage agent as a dedicated linked destination at the bottom.
+
+## 2026-07-24
+
+### Improved
+
+- Secondary controls and dashboard surfaces now use quieter borderless styling.
+- Sidebar utility controls now follow a consistent footer order.
+
+### Fixed
+
+- Signing in now reliably puts you in your company's workspace instead of stranding you in a personal one, and the workspace switcher stays reachable when the sidebar is collapsed.
+
+## 2026-07-23
+
+### Improved
+
+- Agent settings are clearly labeled Manage agent in the sidebar.
+- Dispatch keeps messaging setup and destination details behind focused expandable panels.
+
+## 2026-07-22
+
+### Improved
+
+- Manage agent navigation now uses the connected-nodes icon.
+
+## 2026-07-21
+
+### Fixed
+
+- Slack agent requests recover automatically when the first background handoff is interrupted.
+
+## 2026-07-17
+
+### Added
+
+- Dispatch now offers curated workspace templates that can be used to create private apps.
+
+### Improved
+
+- Dispatch now links to other available apps from the Apps page.
+
+### Fixed
+
+- The agent chat sidebar stays closed until you open it or start a chat handoff.
+
+## 2026-07-14
+
+### Fixed
+
+- Dispatch now distinguishes connected agents from locally mounted apps when routing cross-app work.
+
+## 2026-07-13
+
+### Added
+
+- New Agent page: see and manage your agent's context, files, connections, jobs, and external access in one place
+
+## 2026-07-11
+
+### Improved
+
+- Dispatch MCP connections now start with safer app access and stay signed in more reliably in ChatGPT.
+- Overview and Chat now share a cleaner flow with cross-app prompting, smoother transitions, and a stable bottom chat field.
+
+### Fixed
+
+- Data loading failures now show a clear error with a retry option instead of appearing as empty lists.
+
+## 2026-07-10
+
+### Added
+
+- Connect Slack workspaces with OAuth, Agent view, and direct messages, then manage channel identity, memory, routines, policies, and AI budgets.
+- Microsoft Teams bots and Discord slash commands can now connect with verified webhooks, while Telegram topics and WhatsApp replies preserve conversation context.
+
+### Improved
+
+- Dispatch now has a cleaner chat history and quieter sidebar identity.
+- Dispatch now groups its workspace controls more clearly and adds an Operations console for agent monitoring, experiments, feedback, and Code-mode database inspection.
+- Slack and Telegram now route uptime-monitor requests to Analytics and return the created monitor link
+
+## 2026-07-08
+
+### Added
+
+- Added an Automations page to review, pause, and create scheduled or event-triggered jobs.
+
+### Improved
+
+- Destinations now shows outbound delivery-queue health, and Overview links quietly to Automations and other workspace tools.
+- Settings are cleaner and searchable, with a consistent navigation that jumps straight to any setting.
+
+## 2026-07-07
+
+### Improved
+
+- Overview is now just Ask Dispatch and a list of apps you can open.
+
+## 2026-06-29
+
+### Fixed
+
+- Integration layouts now adapt cleanly when the agent sidebar narrows the app.
+
+## 2026-06-27
+
+### Fixed
+
+- Traditional Chinese copy now uses Taiwan terminology and clearer technical wording.
+
+## 2026-06-24
+
+### Added
+
+- A new Settings page gives quick access to language, workspace, and agent preferences.
+- Added a language picker and localized app chrome for supported languages.
+
+For the full list of updates, see the [changelog folder](./changelog/).