@agent-native/core 0.68.3 → 0.70.0

package/corpus/templates/clips/changelog/2026-06-23-screen-camera-recordings-now-keep-the-presenter-s-face-in-th.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-06-23
+---
+
+Screen + camera recordings now keep the presenter's face in the thumbnail shown on the library card, video poster, and Slack unfurl

package/corpus/templates/clips/desktop/src/lib/recorder.ts

@@ -1473,6 +1473,22 @@ async function showRegionGuidesForRecording(wantsScreen: boolean) {
   });
 }
 
+// Frame the chosen screen region with a live border so the user can see exactly
+// what's being captured throughout the countdown and recording. The overlay is
+// capture-excluded and draws its stroke outside the captured pixels, so it never
+// lands in the video. Torn down with the rest of the recording chrome on stop.
+async function showRegionRecordBorder(region: RegionCaptureRect | null) {
+  if (!region) return;
+  await invoke("show_region_record_border", {
+    x: region.x,
+    y: region.y,
+    width: region.width,
+    height: region.height,
+  }).catch((err) => {
+    console.warn("[clips-recorder] show_region_record_border failed:", err);
+  });
+}
+
 async function runRecordingCountdown(wantsScreen: boolean, audioCue: AudioCue) {
   const countdownEvent = waitForCountdownEvent(
     COUNTDOWN_EVENT_TIMEOUT_MS,
@@ -1566,6 +1582,10 @@ async function startNativeFullscreenRecording(
 
     if (params.source === "region") {
       captureRegion = await selectRegionForRecording();
+      // Frame the selected area now so it stays visible through the countdown
+      // and the whole recording. hide_recording_chrome / hide_overlays tear it
+      // down on stop, cancel, and the error paths below.
+      await showRegionRecordBorder(captureRegion);
     }
 
     if (localOnly && localRecordingMode === "separate" && wantsCamera) {

package/corpus/templates/clips/desktop/src/main.tsx

@@ -12,6 +12,7 @@ import { MeetingNub } from "./overlays/meeting-nub";
 import { FlowBar } from "./overlays/flow-bar";
 import { RecordingPill } from "./overlays/recording-pill";
 import { RegionGuideEditor, RegionGuides } from "./overlays/region-guides";
+import { RegionRecordBorder } from "./overlays/region-record-border";
 import "./styles.css";
 
 /**
@@ -55,6 +56,8 @@ function pickRoute(route: string): React.ReactElement {
       return <RegionGuideEditor />;
     case "region-capture-selector":
       return <RegionGuideEditor mode="capture" />;
+    case "region-record-border":
+      return <RegionRecordBorder />;
     default:
       return <App />;
   }

package/corpus/templates/clips/desktop/src/overlays/region-record-border.tsx

@@ -0,0 +1,76 @@
+import { useEffect, useState } from "react";
+import { getCurrentWindow } from "@tauri-apps/api/window";
+
+interface BorderRect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+function clamp01(value: number): number {
+  if (!Number.isFinite(value)) return 0;
+  return Math.min(1, Math.max(0, value));
+}
+
+/**
+ * The live recording region is handed to this overlay window as a normalized
+ * rect in the URL query (`?region=x,y,width,height`) so it never has to wait
+ * on a Tauri event (which could race the webview load). All four values are
+ * fractions [0,1] of the recording monitor — the same space the region-capture
+ * selector emitted them in.
+ */
+function parseRect(search: string): BorderRect | null {
+  const raw = new URLSearchParams(search).get("region");
+  if (!raw) return null;
+  const parts = raw.split(",").map((value) => Number.parseFloat(value));
+  if (parts.length !== 4 || parts.some((value) => !Number.isFinite(value))) {
+    return null;
+  }
+  const [x, y, width, height] = parts;
+  if (width <= 0 || height <= 0) return null;
+  return {
+    x: clamp01(x),
+    y: clamp01(y),
+    width: clamp01(width),
+    height: clamp01(height),
+  };
+}
+
+/**
+ * A thin frame painted around the screen region currently being recorded. The
+ * window itself is full-screen, click-through, and capture-excluded (see
+ * `show_region_record_border` on the Rust side). The frame is drawn entirely
+ * OUTWARD via an outset box-shadow with no fill, so its pixels sit just outside
+ * the captured rect and never leak into the recording even on the macOS 15.4+
+ * builds where `NSWindowSharingNone` is occasionally bypassed.
+ */
+export function RegionRecordBorder() {
+  const [rect] = useState<BorderRect | null>(() =>
+    typeof window === "undefined" ? null : parseRect(window.location.search),
+  );
+
+  useEffect(() => {
+    if (rect) return;
+    // No usable region — close the overlay so an empty window never lingers.
+    getCurrentWindow()
+      .close()
+      .catch(() => {});
+  }, [rect]);
+
+  if (!rect) return null;
+
+  return (
+    <div className="region-record-border-layer" aria-hidden>
+      <div
+        className="region-record-border-frame"
+        style={{
+          left: `${rect.x * 100}%`,
+          top: `${rect.y * 100}%`,
+          width: `${rect.width * 100}%`,
+          height: `${rect.height * 100}%`,
+        }}
+      />
+    </div>
+  );
+}

package/corpus/templates/clips/desktop/src/styles.css

@@ -3749,6 +3749,55 @@ body[data-clips-route="recording-pill"] #root {
   backdrop-filter: blur(14px);
 }
 
+/* ------------------------------------------------------------------------- */
+/* Overlay: live recording-region border                                      */
+/* ------------------------------------------------------------------------- */
+
+.region-record-border-layer {
+  position: fixed;
+  inset: 0;
+  width: 100vw;
+  height: 100vh;
+  overflow: hidden;
+  pointer-events: none;
+}
+
+.region-record-border-frame {
+  position: absolute;
+  border-radius: 5px;
+  /* No fill, and the stroke is painted OUTWARD with an outset box-shadow so it
+     lands just outside the captured rect — never inside the recorded video. */
+  box-shadow:
+    0 0 0 2px rgba(239, 68, 68, 0.95),
+    0 0 0 4px rgba(239, 68, 68, 0.32),
+    0 0 26px 6px rgba(239, 68, 68, 0.26);
+  animation: region-record-border-pulse 1.8s ease-in-out infinite;
+}
+
+/* Gentle pulse that mirrors the live recording dot, signalling "recording
+   now". Honour reduced-motion by holding the frame steady. */
+@keyframes region-record-border-pulse {
+  0%,
+  100% {
+    box-shadow:
+      0 0 0 2px rgba(239, 68, 68, 0.9),
+      0 0 0 4px rgba(239, 68, 68, 0.28),
+      0 0 22px 5px rgba(239, 68, 68, 0.2);
+  }
+  50% {
+    box-shadow:
+      0 0 0 2px rgba(239, 68, 68, 1),
+      0 0 0 4px rgba(239, 68, 68, 0.44),
+      0 0 30px 8px rgba(239, 68, 68, 0.34);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .region-record-border-frame {
+    animation: none;
+  }
+}
+
 @keyframes flow-bar-in {
   from {
     opacity: 0;

package/corpus/templates/clips/desktop/src-tauri/capabilities/default.json

@@ -15,7 +15,8 @@
     "flow-bar",
     "recording-pill",
     "region-guides",
-    "region-guide-editor"
+    "region-guide-editor",
+    "region-record-border"
   ],
   "permissions": [
     "core:default",

package/corpus/templates/clips/desktop/src-tauri/src/clips/mod.rs

@@ -31,6 +31,7 @@ const FINALIZING_LABEL: &str = "finalizing";
 const FLOW_BAR_LABEL: &str = "flow-bar";
 const REGION_GUIDES_LABEL: &str = "region-guides";
 const REGION_GUIDE_EDITOR_LABEL: &str = "region-guide-editor";
+const REGION_RECORD_BORDER_LABEL: &str = "region-record-border";
 
 /// Physical-pixel bubble sizes. Logical px on retina = physical / 2, so these
 /// map to ~96 (small) and ~180 (medium) logical px — matching Loom's camera
@@ -448,6 +449,65 @@ pub async fn hide_region_guides(app: AppHandle) -> Result<(), String> {
     Ok(())
 }
 
+/// Live border framing the region currently being recorded. Like the region
+/// guides this is a full-screen, click-through, capture-excluded overlay — but
+/// the rect is ephemeral (it belongs to one recording, not the saved preset),
+/// so it's handed in via the URL query rather than read from config. The React
+/// view paints only an OUTWARD frame so the stroke stays out of the captured
+/// pixels. The recording flow owns this window; it's torn down by
+/// `hide_recording_chrome` / `hide_overlays` when capture stops.
+#[tauri::command]
+pub async fn show_region_record_border(
+    app: AppHandle,
+    x: f64,
+    y: f64,
+    width: f64,
+    height: f64,
+) -> Result<(), String> {
+    if !(width > 0.0 && height > 0.0) {
+        return Ok(());
+    }
+    if let Some(existing) = app.get_webview_window(REGION_RECORD_BORDER_LABEL) {
+        let _ = existing.close();
+    }
+
+    let (mx, my, mw, mh) = tray_monitor_physical_rect(&app);
+    let url = WebviewUrl::App(
+        format!("index.html?region={x:.6},{y:.6},{width:.6},{height:.6}#region-record-border")
+            .into(),
+    );
+    let win = WebviewWindowBuilder::new(&app, REGION_RECORD_BORDER_LABEL, url)
+        .title("Clips Recording Region")
+        .decorations(false)
+        .transparent(true)
+        .always_on_top(true)
+        .skip_taskbar(true)
+        .resizable(false)
+        .shadow(false)
+        .visible(false)
+        .focused(false)
+        .build()
+        .map_err(|e| {
+            eprintln!("[clips-tray] region record border build failed: {}", e);
+            e.to_string()
+        })?;
+    let _ = win.set_size(tauri::Size::Physical(PhysicalSize::new(mw, mh)));
+    let _ = win.set_position(PhysicalPosition::new(mx, my));
+    let _ = win.set_ignore_cursor_events(true);
+    set_capture_excluded_always(&win);
+    configure_overlay_behavior(&win);
+    crate::util::show_without_activation(&win);
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn hide_region_record_border(app: AppHandle) -> Result<(), String> {
+    if let Some(w) = app.get_webview_window(REGION_RECORD_BORDER_LABEL) {
+        let _ = w.close();
+    }
+    Ok(())
+}
+
 /// Reconcile the always-on region-guides overlay with the current config.
 /// Called from config saves and on startup so the guides window matches the
 /// `always_visible` toggle without needing a recording-flow round trip. When a
@@ -748,6 +808,7 @@ pub async fn hide_overlays(app: AppHandle) -> Result<(), String> {
         FINALIZING_LABEL,
         FLOW_BAR_LABEL,
         REGION_GUIDES_LABEL,
+        REGION_RECORD_BORDER_LABEL,
     ] {
         if let Some(w) = app.get_webview_window(label) {
             let _ = w.close();
@@ -772,7 +833,9 @@ pub async fn hide_recording_chrome(app: AppHandle) -> Result<(), String> {
     // toggle — otherwise we'd flicker close→reopen right after stop.
     let g = crate::config::feature_config(&app).region_guides;
     let keep_region_guides = g.always_visible && g.enabled && !g.rects.is_empty();
-    let mut labels: Vec<&str> = vec![COUNTDOWN_LABEL, TOOLBAR_LABEL];
+    // The recording-region border belongs to a single recording (never pinned),
+    // so it always tears down here alongside the countdown + toolbar.
+    let mut labels: Vec<&str> = vec![COUNTDOWN_LABEL, TOOLBAR_LABEL, REGION_RECORD_BORDER_LABEL];
     if !keep_region_guides {
         labels.push(REGION_GUIDES_LABEL);
     }
@@ -1438,6 +1501,9 @@ pub async fn reset_state(app: AppHandle) -> Result<(), String> {
     if let Some(w) = app.get_webview_window(REGION_GUIDES_LABEL) {
         let _ = w.close();
     }
+    if let Some(w) = app.get_webview_window(REGION_RECORD_BORDER_LABEL) {
+        let _ = w.close();
+    }
     if let Some(window) = app.get_webview_window("popover") {
         // Restore normal size in case the window was shrunk to a pinhole
         // during recording — otherwise it would reappear as a 2×2 dot.

package/corpus/templates/clips/desktop/src-tauri/src/lib.rs

@@ -68,6 +68,8 @@ pub fn run() {
             clips::hide_recording_chrome,
             clips::show_region_guides,
             clips::hide_region_guides,
+            clips::show_region_record_border,
+            clips::hide_region_record_border,
             clips::show_region_guide_editor,
             clips::show_region_capture_selector,
             clips::close_bubble,

package/corpus/templates/clips/desktop/src-tauri/src/util.rs

@@ -208,7 +208,10 @@ pub fn reapply_capture_exclusion_to_overlays(app: &tauri::AppHandle) {
                 set_window_capture_excluded(window, false);
                 continue;
             }
-            let private_guide = matches!(label.as_str(), "region-guides" | "region-guide-editor");
+            let private_guide = matches!(
+                label.as_str(),
+                "region-guides" | "region-guide-editor" | "region-record-border"
+            );
             set_window_capture_excluded(window, private_guide || !visible);
         }
     }

package/corpus/templates/clips/server/routes/api/video/[recordingId].get.ts

@@ -49,6 +49,7 @@ import {
 import { getOrgContext } from "@agent-native/core/org";
 import { resolveAccess } from "@agent-native/core/sharing";
 import {
+  captureRouteError,
   getSession,
   runWithRequestContext,
   signShortLivedToken,
@@ -404,7 +405,56 @@ export default defineEventHandler(async (event: H3Event) => {
           setResponseStatus(event, upstream.status);
           return { error: upstream.error };
         }
-        return providerResponse(upstream);
+        // The provider answered, but with a server error (e.g. the CDN asset is
+        // broken and returns 5xx). Don't proxy an opaque upstream error — and
+        // don't risk reconstructing a Response from it, which previously threw
+        // and surfaced as an unhandled 500 on every request. Capture it so the
+        // broken asset is diagnosable, and return a clean 502.
+        if (upstream.status >= 500) {
+          captureRouteError(
+            new Error(
+              `Storage provider returned ${upstream.status} for recording media`,
+            ),
+            {
+              route: "api/video",
+              tags: {
+                mediaPath: "provider-proxy",
+                upstreamStatus: String(upstream.status),
+              },
+              extra: { recordingId },
+            },
+          );
+          setResponseStatus(event, 502);
+          setResponseHeader(
+            event,
+            "Cache-Control",
+            "private, max-age=0, no-store",
+          );
+          return {
+            error: "The recording's media could not be loaded from storage.",
+            upstreamStatus: upstream.status,
+          };
+        }
+        try {
+          return providerResponse(upstream);
+        } catch (err) {
+          // Reconstructing the proxied Response should not happen, but if it
+          // does, fail cleanly instead of as an unhandled 500.
+          captureRouteError(err, {
+            route: "api/video",
+            tags: { mediaPath: "provider-proxy-response" },
+            extra: { recordingId, upstreamStatus: String(upstream.status) },
+          });
+          setResponseStatus(event, 502);
+          setResponseHeader(
+            event,
+            "Cache-Control",
+            "private, max-age=0, no-store",
+          );
+          return {
+            error: "The recording's media could not be loaded from storage.",
+          };
+        }
       }
       const mimeType =
         typeof blob?.mimeType === "string" ? blob.mimeType : "video/webm";

package/corpus/templates/clips/shared/share-attribution.ts

@@ -0,0 +1,79 @@
+/**
+ * Viral attribution contract for shared Clips links.
+ *
+ * Shared clip URLs self-attribute so the signup funnel can be measured even
+ * when `document.referrer` is empty (desktop app, Slack, native clients, etc.).
+ * The framework captures first-touch from these params into a cookie and
+ * enriches the `signup` event; Clips' job is to (a) tag share/embed URLs and
+ * (b) emit funnel events from the public share page.
+ *
+ * Contract strings are centralized here so the minting side (share dialog) and
+ * the measuring side (public share page) cannot drift apart.
+ *
+ * Privacy: `via` must be a non-PII stable id (e.g. the owner's user id), never
+ * an email. Omit `via` rather than leak PII into a public URL or event.
+ */
+
+/** Fixed referral source for clip shares. */
+export const CLIP_SHARE_REF = "clip_share";
+
+/** Query param names that carry attribution. */
+export const REF_PARAM = "ref";
+export const VIA_PARAM = "via";
+
+/**
+ * Append `ref=clip_share` (and `via=<ownerId>` when a non-PII owner id is
+ * known) to an absolute share/embed URL, preserving any existing query params.
+ * Returns the input unchanged when it isn't a parseable absolute URL.
+ */
+export function withShareAttribution(
+  url: string,
+  ownerId?: string | null,
+): string {
+  if (!url) return url;
+  try {
+    const parsed = new URL(url);
+    parsed.searchParams.set(REF_PARAM, CLIP_SHARE_REF);
+    const owner = (ownerId ?? "").trim();
+    if (owner) parsed.searchParams.set(VIA_PARAM, owner);
+    return parsed.toString();
+  } catch {
+    return url;
+  }
+}
+
+export type ShareAttribution = {
+  ref: string | undefined;
+  via: string | undefined;
+};
+
+/**
+ * Read `ref`/`via` from a query string (e.g. `window.location.search`). Falls
+ * back to `ref=clip_share` so downstream attribution stays meaningful even when
+ * the visitor arrived via a link that lost the param.
+ */
+export function readShareAttribution(search: string): ShareAttribution {
+  let ref: string | undefined;
+  let via: string | undefined;
+  try {
+    const params = new URLSearchParams(search ?? "");
+    ref = params.get(REF_PARAM) ?? undefined;
+    via = params.get(VIA_PARAM) ?? undefined;
+  } catch {
+    // Ignore malformed query strings — fall through to the default below.
+  }
+  return { ref: ref || CLIP_SHARE_REF, via: via || undefined };
+}
+
+/**
+ * Build the attribution-forwarding signup path so attribution survives even if
+ * cookies are blocked. The framework also captures these params on the
+ * `/signup` page load.
+ */
+export function buildSignupAttributionQuery(via?: string | null): string {
+  const params = new URLSearchParams();
+  params.set(REF_PARAM, CLIP_SHARE_REF);
+  const owner = (via ?? "").trim();
+  if (owner) params.set(VIA_PARAM, owner);
+  return params.toString();
+}

package/corpus/templates/content/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+All notable user-facing changes to Agent-Native Content are documented here. Open it any
+time from the command menu (Cmd+K → "What's new").
+
+## 2026-06-23
+
+### Added
+
+- See what's new right inside Agent-Native Content — a changelog now lives in the command menu (Cmd+K).

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

@@ -26,6 +26,7 @@ import {
 } from "@agent-native/core/client";
 import { useDbSync } from "./hooks/use-db-sync";
 import { useNavigationState } from "./hooks/use-navigation-state";
+import changelog from "../CHANGELOG.md?raw";
 import type { LinksFunction } from "react-router";
 import stylesheet from "./global.css?url";
 import { configureTracking } from "@agent-native/core/client";
@@ -247,7 +248,12 @@ export default function Root() {
     >
       <AppSetup />
       <Toaster />
-      <CommandMenu open={cmdkOpen} onOpenChange={setCmdkOpen}>
+      <CommandMenu
+        open={cmdkOpen}
+        onOpenChange={setCmdkOpen}
+        changelog={changelog}
+        changelogKey="content"
+      >
         <CommandMenu.Group heading="Content">
           <CommandMenu.Item onSelect={() => {}}>
             Search documents

package/corpus/templates/content/vitest.config.ts

@@ -13,5 +13,8 @@ export default defineConfig({
   test: {
     include: ["**/*.{test,spec}.?(c|m)[jt]s?(x)"],
     exclude: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/e2e/**"],
+    hookTimeout: 60_000,
+    testTimeout: 60_000,
+    maxWorkers: "50%",
   },
 });

package/corpus/templates/design/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+All notable user-facing changes to Design are documented here. Open it any time
+from the command menu (Cmd+K → "What's new") or from Settings.
+
+## 2026-06-23
+
+### Added
+
+- See what's new right inside Design — a changelog now lives in the command menu (Cmd+K) and in Settings.

package/corpus/templates/design/actions/generate-design.ts

@@ -29,6 +29,10 @@ export default defineAction({
     "The agent calls this after generating HTML/CSS/JSX content to persist it " +
     "as files in the design project. Creates or updates files as needed. " +
     "Returns the saved files and design URL path for iframe rendering. " +
+    "Keep the first save compact and working; for large designs, persist a minimal " +
+    "version then refine individual files with `edit-design` (search/replace) rather " +
+    "than resending a big multi-file payload — a single oversized payload can get cut " +
+    "off mid-stream and stall the turn. " +
     "Do not report a design as ready until this action succeeds.",
   schema: z.object({
     designId: z.string().describe("Design project ID to save content to"),

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

@@ -14,6 +14,7 @@ import {
   configureTracking,
 } from "@agent-native/core/client";
 import { IconSun, IconMoon } from "@tabler/icons-react";
+import changelog from "../CHANGELOG.md?raw";
 import { Toaster } from "@/components/ui/sonner";
 import { Layout as AppLayout } from "@/components/layout/Layout";
 import type { LinksFunction } from "react-router";
@@ -99,7 +100,12 @@ export default function Root() {
     <AppProviders queryClient={queryClient}>
       <DbSyncSetup />
       <Toaster richColors position="bottom-left" />
-      <CommandMenu open={cmdkOpen} onOpenChange={setCmdkOpen}>
+      <CommandMenu
+        open={cmdkOpen}
+        onOpenChange={setCmdkOpen}
+        changelog={changelog}
+        changelogKey="design"
+      >
         <CommandMenu.Group heading="Actions">
           <CommandMenu.Item onSelect={() => {}}>Search</CommandMenu.Item>
         </CommandMenu.Group>

package/corpus/templates/design/app/routes/settings.tsx

@@ -1,4 +1,9 @@
-import { SettingsPanel, useDevMode } from "@agent-native/core/client";
+import {
+  SettingsPanel,
+  useDevMode,
+  ChangelogSettingsCard,
+} from "@agent-native/core/client";
+import changelog from "../../CHANGELOG.md?raw";
 
 export function meta() {
   return [{ title: "Settings — Design" }];
@@ -8,12 +13,15 @@ export default function SettingsRoute() {
   const { isDevMode, canToggle, setDevMode } = useDevMode();
 
   return (
-    <div className="flex h-full min-h-0 flex-col bg-background">
+    <div className="flex h-full min-h-0 flex-col overflow-y-auto bg-background">
       <SettingsPanel
         isDevMode={isDevMode}
         onToggleDevMode={() => setDevMode(!isDevMode)}
         showDevToggle={canToggle}
       />
+      <div className="mx-auto w-full max-w-2xl px-4 pb-8">
+        <ChangelogSettingsCard markdown={changelog} />
+      </div>
     </div>
   );
 }

package/corpus/templates/dispatch/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+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").
+
+## 2026-06-23
+
+### Added
+
+- See what's new right inside Agent-Native Dispatch — a changelog now lives in the command menu (Cmd+K).

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

@@ -25,6 +25,7 @@ import { useTheme } from "next-themes";
 import { Layout as AppLayout } from "@agent-native/dispatch/components";
 import type { LinksFunction } from "react-router";
 import { dispatchExtensions } from "./dispatch-extensions";
+import changelog from "../CHANGELOG.md?raw";
 import stylesheet from "./global.css?url";
 
 configureTracking({
@@ -166,7 +167,12 @@ function AppContent() {
   return (
     <>
       <DbSyncSetup />
-      <CommandMenu open={cmdkOpen} onOpenChange={setCmdkOpen}>
+      <CommandMenu
+        open={cmdkOpen}
+        onOpenChange={setCmdkOpen}
+        changelog={changelog}
+        changelogKey="dispatch"
+      >
         <CommandMenu.Group heading="Actions">
           <CommandMenu.Item onSelect={() => {}}>Search</CommandMenu.Item>
         </CommandMenu.Group>

package/corpus/templates/forms/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+All notable user-facing changes to Agent-Native Forms are documented here. Open it any
+time from the command menu (Cmd+K → "What's new").
+
+## 2026-06-23
+
+### Added
+
+- See what's new right inside Agent-Native Forms — a changelog now lives in the command menu (Cmd+K).

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

@@ -27,6 +27,7 @@ import {
   setClientAppState,
 } from "@agent-native/core/client";
 import type { LinksFunction } from "react-router";
+import changelog from "../CHANGELOG.md?raw";
 import stylesheet from "./global.css?url";
 import { TAB_ID } from "@/lib/tab-id";
 
@@ -198,7 +199,12 @@ export default function Root() {
       <NavigationStateSync />
       <UrlStateSync />
       <OpenLinkInterceptor />
-      <CommandMenu open={cmdkOpen} onOpenChange={setCmdkOpen}>
+      <CommandMenu
+        open={cmdkOpen}
+        onOpenChange={setCmdkOpen}
+        changelog={changelog}
+        changelogKey="forms"
+      >
         <CommandMenu.Group heading="Forms">
           <CommandMenu.Item onSelect={() => {}}>Search forms</CommandMenu.Item>
         </CommandMenu.Group>