@agent-native/core 0.178.1-nightly-20260910175201 → 0.178.1

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 9127
+- template files: 9134

package/corpus/templates/analytics/CHANGELOG.md

@@ -7,6 +7,7 @@ time from the command menu (Cmd+K → "What's new") or from Settings.
 
 ### Improved
 
+- Faster analytics dashboard loading
 - Collaborator avatars use a slimmer border.
 
 ## 2026-09-08

package/corpus/templates/calendar/CHANGELOG.md

@@ -3,10 +3,17 @@
 All notable user-facing changes to Agent-Native Calendar are documented here. Open it any
 time from the command menu (Cmd+K → "What's new") or from Settings.
 
+## 2026-09-10
+
+### Fixed
+
+- Calendar keeps shared and overlaid events read-only instead of reporting a false deletion
+
 ## 2026-09-09
 
 ### Improved
 
+- Calendar's command menu surfaces the right actions for booking links and settings
 - Calendar can color Google events by meeting type again
 - Connected account avatars use a slimmer border.
 

package/corpus/templates/clips/CHANGELOG.md

@@ -3,12 +3,34 @@
 All notable user-facing changes to Clips are documented here. Open it any time
 from the command menu (Cmd+K → "What's new") or from Settings.
 
+## 2026-09-10
+
+### Fixed
+
+- Builder and other MCP connections now open setup in a new tab.
+
 ## 2026-09-09
 
 ### Improved
 
 - Attendee and viewer avatars use a slimmer border.
 
+### Fixed
+
+- The Agent sidebar now fits below the app toolbar without clipping its composer.
+- Desktop recorder switches now keep their checked state clear and legible in dark mode.
+- Recording pages now open the same contextual Agent panel used throughout the app.
+
+## 2026-09-08
+
+### Improved
+
+- The Cmd+K command menu now searches and navigates across recordings, meetings, dictations, folders, and spaces.
+
+### Fixed
+
+- Fixed desktop comment threads by keeping them in a full-height viewer tab, polished the side-panel tabs and spacing, added move, minimize, and close controls to desktop Clips windows, corrected the shared New recording action’s split-button corners, made library sub-item selection clear in the sidebar, and added visible folder tiles plus scoped recording actions to library and space views.
+
 ## 2026-09-04
 
 ### Fixed

package/corpus/templates/clips/actions/create-intake-agent-link.ts

@@ -0,0 +1,114 @@
+import { defineAction, fail } from "@agent-native/core/action";
+import {
+  getRequestContext,
+  getRequestUserEmail,
+  runWithRequestContext,
+} from "@agent-native/core/server";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import { findOwnedClipIntakeSession } from "../server/lib/clip-intake.js";
+import {
+  getActiveOrganizationId,
+  ownerEmailMatches,
+  requireOrganizationAccess,
+} from "../server/lib/recordings.js";
+import { BUG_REPORT_AGENT_ACCESS_TTL_SECONDS } from "../shared/bug-report.js";
+import createRecordingAgentLink from "./create-recording-agent-link.js";
+
+export default defineAction({
+  description:
+    "Create a temporary read-only agent link for a completed Clips intake recording. This is an authenticated host-side exchange; the anonymous intake bearer cannot mint read access.",
+  agentTool: false,
+  requiresAuth: true,
+  http: { method: "POST" },
+  maxBodyBytes: 16 * 1024,
+  schema: z.object({
+    intakeId: z.string().min(16).max(80),
+    recordingId: z.string().min(1).max(200),
+    ttlSeconds: z
+      .number()
+      .int()
+      .positive()
+      .max(BUG_REPORT_AGENT_ACCESS_TTL_SECONDS)
+      .optional(),
+  }),
+  run: async (args) => {
+    const ownerEmail = getRequestUserEmail();
+    if (!ownerEmail) {
+      fail("Sign in to exchange an intake for agent access.", {
+        errorCode: "authentication_required",
+        statusCode: 401,
+      });
+    }
+    const organizationId = await getActiveOrganizationId();
+    const access = await requireOrganizationAccess(organizationId);
+    const session = await findOwnedClipIntakeSession(
+      args.intakeId,
+      access.email,
+      access.organizationId,
+    );
+    if (
+      !session ||
+      session.recordingId !== args.recordingId ||
+      session.status !== "completed"
+    ) {
+      fail("This intake recording is not available.", {
+        errorCode: "intake_recording_unavailable",
+        statusCode: 404,
+      });
+    }
+
+    const [recording] = await getDb()
+      .select({
+        id: schema.recordings.id,
+        status: schema.recordings.status,
+        videoUrl: schema.recordings.videoUrl,
+        archivedAt: schema.recordings.archivedAt,
+        trashedAt: schema.recordings.trashedAt,
+      })
+      .from(schema.recordings)
+      .where(
+        and(
+          eq(schema.recordings.id, args.recordingId),
+          ownerEmailMatches(schema.recordings.ownerEmail, session.ownerEmail),
+          eq(schema.recordings.organizationId, session.organizationId),
+        ),
+      )
+      .limit(1);
+    if (
+      !recording ||
+      recording.status !== "ready" ||
+      !recording.videoUrl ||
+      recording.archivedAt ||
+      recording.trashedAt
+    ) {
+      fail("This intake recording is not available yet.", {
+        errorCode: "intake_recording_not_ready",
+        statusCode: 409,
+      });
+    }
+
+    const requestOrigin = getRequestContext()?.requestOrigin;
+    return runWithRequestContext(
+      {
+        userEmail: session.ownerEmail,
+        orgId: session.organizationId,
+        requestOrigin,
+      },
+      () =>
+        createRecordingAgentLink.run(
+          {
+            recordingId: args.recordingId,
+            ttlSeconds: args.ttlSeconds,
+          },
+          {
+            caller: "http",
+            userEmail: session.ownerEmail,
+            orgId: session.organizationId,
+          },
+        ),
+    );
+  },
+});

package/corpus/templates/clips/actions/create-intake-recording.ts

@@ -0,0 +1,208 @@
+import { defineAction, fail } from "@agent-native/core/action";
+import { runWithRequestContext } from "@agent-native/core/server";
+import { z } from "zod";
+
+import {
+  abandonClipIntake,
+  attachClipIntakeRecording,
+  claimClipIntakeRecording,
+  findClipIntakeSession,
+  findRecoverableClipIntakeRecording,
+  releaseClipIntakeCreation,
+} from "../server/lib/clip-intake.js";
+import { getResumableSession } from "../server/lib/resumable-session.js";
+import { BUG_REPORT_SEVERITIES } from "../shared/bug-report.js";
+import { buildClipIntakeUrl } from "../shared/clip-intake.js";
+import createRecording from "./create-recording.js";
+import { createRecordingSchema } from "./lib/create-recording-schema.js";
+import saveBugReportContext from "./save-bug-report-context.js";
+import trashRecording from "./trash-recording.js";
+
+const bugReportSchema = z.object({
+  projectId: z.string().max(120).nullish(),
+  title: z.string().max(500).nullish(),
+  description: z.string().max(5_000).nullish(),
+  severity: z.enum(BUG_REPORT_SEVERITIES).default("normal"),
+  sourceUrl: z.string().max(8_000).nullish(),
+  pageTitle: z.string().max(500).nullish(),
+  appVersion: z.string().max(120).nullish(),
+  environment: z.string().max(120).nullish(),
+  reporterEmail: z.string().max(320).nullish(),
+  reporterName: z.string().max(200).nullish(),
+  reporterId: z.string().max(200).nullish(),
+  metadata: z.record(z.string(), z.unknown()).nullish(),
+});
+
+const intakeRecordingSchema = createRecordingSchema
+  .omit({ id: true, folderId: true, spaceIds: true, organizationId: true })
+  .extend({
+    intakeId: z.string().min(16).max(80),
+    intakeToken: z.string().min(1).max(4096),
+    bugReport: bugReportSchema.nullish(),
+  });
+
+function intakeUploadUrls(
+  intakeId: string,
+  intakeToken: string,
+  recordingId: string,
+) {
+  return {
+    uploadChunkUrl: buildClipIntakeUrl("/api/clip-intake", {
+      recordingId,
+      operation: "chunk",
+      intakeId,
+      token: intakeToken,
+    }),
+    resetChunksUrl: buildClipIntakeUrl("/api/clip-intake", {
+      recordingId,
+      operation: "reset",
+      intakeId,
+      token: intakeToken,
+    }),
+    abortUrl: buildClipIntakeUrl("/api/clip-intake", {
+      recordingId,
+      operation: "abort",
+      intakeId,
+      token: intakeToken,
+    }),
+  };
+}
+
+export default defineAction({
+  description:
+    "Create the one recording allowed by a signed Clips intake URL. This is a write-only anonymous capability and never grants library or agent read access.",
+  agentTool: false,
+  requiresAuth: false,
+  http: { method: "POST" },
+  maxBodyBytes: 64 * 1024,
+  schema: intakeRecordingSchema,
+  run: async (args) => {
+    const claimed = await claimClipIntakeRecording(
+      args.intakeId,
+      args.intakeToken,
+    );
+    if (!claimed) {
+      const existingSession = await findClipIntakeSession(
+        args.intakeId,
+        args.intakeToken,
+      );
+      const existing = existingSession
+        ? await findRecoverableClipIntakeRecording(existingSession)
+        : null;
+      if (existing && existingSession) {
+        const resumableSession = await getResumableSession(existing.id);
+        return {
+          id: existing.id,
+          organizationId: existing.organizationId,
+          status: "uploading" as const,
+          uploadMode: resumableSession ? ("streaming" as const) : "buffered",
+          ...intakeUploadUrls(args.intakeId, args.intakeToken, existing.id),
+        };
+      }
+      fail("This intake URL has expired or has already been used.", {
+        errorCode: "intake_unavailable",
+        statusCode: 409,
+      });
+    }
+
+    const { intakeId, intakeToken, bugReport, ...recordingArgs } = args;
+    let created: Awaited<ReturnType<typeof createRecording.run>>;
+    try {
+      created = await runWithRequestContext(
+        {
+          userEmail: claimed.ownerEmail,
+          orgId: claimed.organizationId,
+        },
+        () =>
+          createRecording.run(
+            {
+              ...recordingArgs,
+              organizationId: claimed.organizationId,
+              visibility: "private",
+            },
+            {
+              caller: "http",
+              userEmail: claimed.ownerEmail,
+              orgId: claimed.organizationId,
+            },
+          ),
+      );
+    } catch (error) {
+      await releaseClipIntakeCreation(intakeId);
+      throw error;
+    }
+
+    const cleanupCreatedRecording = async () => {
+      await abandonClipIntake(intakeId).catch((cleanupError: unknown) => {
+        console.warn("[clip-intake] session cleanup failed:", cleanupError);
+      });
+      await Promise.resolve(
+        runWithRequestContext(
+          {
+            userEmail: claimed.ownerEmail,
+            orgId: claimed.organizationId,
+          },
+          () =>
+            trashRecording.run(
+              { id: created.id, skipIfReady: true },
+              {
+                caller: "http",
+                userEmail: claimed.ownerEmail,
+                orgId: claimed.organizationId,
+              },
+            ),
+        ),
+      ).catch((cleanupError: unknown) => {
+        console.warn("[clip-intake] recording cleanup failed:", cleanupError);
+      });
+    };
+
+    if (bugReport) {
+      try {
+        await runWithRequestContext(
+          {
+            userEmail: claimed.ownerEmail,
+            orgId: claimed.organizationId,
+          },
+          () =>
+            saveBugReportContext.run(
+              {
+                recordingId: created.id,
+                ...bugReport,
+                metadata: bugReport.metadata ?? undefined,
+              },
+              {
+                caller: "http",
+                userEmail: claimed.ownerEmail,
+                orgId: claimed.organizationId,
+              },
+            ),
+        );
+      } catch {
+        await cleanupCreatedRecording();
+        fail(
+          "Could not save the bug report context. This intake was not completed. Try again.",
+          {
+            errorCode: "intake_context_unavailable",
+            statusCode: 503,
+          },
+        );
+      }
+    }
+
+    try {
+      await attachClipIntakeRecording(intakeId, created.id);
+    } catch (error) {
+      await cleanupCreatedRecording();
+      throw error;
+    }
+
+    return {
+      id: created.id,
+      organizationId: created.organizationId,
+      status: created.status,
+      uploadMode: created.uploadMode,
+      ...intakeUploadUrls(intakeId, intakeToken, created.id),
+    };
+  },
+});

package/corpus/templates/clips/actions/create-recording-intake-link.ts

@@ -0,0 +1,85 @@
+import { defineAction } from "@agent-native/core/action";
+import {
+  buildAgentAccessUrl,
+  createScopedAgentAccessGrant,
+  getAppProductionUrl,
+  getRequestContext,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import { getServerAppBasePath } from "../server/lib/public-agent-context.js";
+import {
+  getActiveOrganizationId,
+  nanoid,
+  requireOrganizationAccess,
+} from "../server/lib/recordings.js";
+import {
+  CLIP_INTAKE_DEFAULT_TTL_SECONDS,
+  CLIP_INTAKE_ID_PARAM,
+  CLIP_INTAKE_MAX_TTL_SECONDS,
+  CLIP_INTAKE_RESOURCE_KIND,
+  CLIP_INTAKE_TOKEN_PARAM,
+} from "../shared/clip-intake.js";
+
+function appOrigin(): string {
+  const origin = getRequestContext()?.requestOrigin || getAppProductionUrl();
+  try {
+    return new URL(origin).origin;
+  } catch {
+    return "http://localhost:3000";
+  }
+}
+
+export default defineAction({
+  description:
+    "Create a short-lived, one-recording Clips intake URL. An anonymous visitor can use it to submit one private recording, but the URL cannot read the Clips library or call agent APIs.",
+  agentTool: false,
+  schema: z.object({
+    ttlSeconds: z
+      .number()
+      .int()
+      .min(60)
+      .max(CLIP_INTAKE_MAX_TTL_SECONDS)
+      .optional()
+      .describe("Intake URL lifetime in seconds. Defaults to one hour."),
+  }),
+  run: async (args) => {
+    const ownerEmail = getRequestUserEmail();
+    if (!ownerEmail) throw new Error("Sign in to create an intake URL.");
+    const organizationId = await getActiveOrganizationId();
+    const access = await requireOrganizationAccess(organizationId);
+    const intakeId = nanoid(24);
+    const ttlSeconds = args.ttlSeconds ?? CLIP_INTAKE_DEFAULT_TTL_SECONDS;
+    const expiresAt = new Date(Date.now() + ttlSeconds * 1000).toISOString();
+
+    await getDb().insert(schema.clipIntakeSessions).values({
+      id: intakeId,
+      ownerEmail: access.email,
+      organizationId: access.organizationId,
+      status: "open",
+      expiresAt,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
+
+    const grant = createScopedAgentAccessGrant({
+      resourceKind: CLIP_INTAKE_RESOURCE_KIND,
+      resourceId: intakeId,
+      ttlSeconds,
+    });
+    const intakePath = `/bug-report?${new URLSearchParams({
+      [CLIP_INTAKE_ID_PARAM]: intakeId,
+    }).toString()}`;
+    const url = buildAgentAccessUrl({
+      path: intakePath,
+      origin: appOrigin(),
+      basePath: getServerAppBasePath(),
+      token: grant.token,
+      tokenParam: CLIP_INTAKE_TOKEN_PARAM,
+    });
+
+    return { intakeId, url, expiresAt: grant.expiresAt, ttlSeconds };
+  },
+});

package/corpus/templates/clips/app/components/bug-report/bug-report-form.tsx

@@ -5,6 +5,7 @@ import {
   type BugReportContext,
   type BugReportSeverity,
 } from "@shared/bug-report";
+import type { ClipIntakeParams } from "@shared/clip-intake";
 import { IconBug, IconShieldCheck } from "@tabler/icons-react";
 import { useEffect, useState } from "react";
 
@@ -24,6 +25,7 @@ import { cn } from "@/lib/utils";
 interface BugReportFormProps {
   className?: string;
   initialContext?: BugReportContext | null;
+  intake?: ClipIntakeParams | null;
   onRecorderOpened?: (recorderWindow: Window | null) => void;
   onRecordingStarted?: () => void;
 }
@@ -45,6 +47,7 @@ function openRecorder(url: string): Window | null {
 export function BugReportForm({
   className,
   initialContext,
+  intake,
   onRecorderOpened,
   onRecordingStarted,
 }: BugReportFormProps) {
@@ -91,6 +94,10 @@ export function BugReportForm({
     params.set("intent", "bug-report");
     params.set("mode", "screen");
     params.set("surface", "browser");
+    if (intake) {
+      params.set("clip_intake_id", intake.intakeId);
+      params.set("clip_intake", intake.token);
+    }
     const recorderWindow = openRecorder(
       `${appBasePath()}/record?${params.toString()}`,
     );

package/corpus/templates/clips/app/components/recorder/recorder-engine.ts

@@ -1,6 +1,7 @@
 import { trackEvent } from "@agent-native/core/client/analytics";
 import { captureClientException } from "@agent-native/core/client/analytics";
 import { appBasePath } from "@agent-native/core/client/api-path";
+import { redactBrowserDiagnosticString } from "@shared/browser-diagnostics";
 import { waitForAcceptedRecordingAfterFinalizeError } from "@shared/finalize-recovery";
 import {
   chooseFallbackAudioInput,
@@ -140,6 +141,8 @@ export interface RecorderEngineOptions {
   uploadUrl?: string;
   /** Abort URL. Default `/api/uploads/:id/abort`. */
   abortUrl?: string;
+  /** Reset-chunks URL. Defaults to the authenticated recording route. */
+  resetUrl?: string;
   /**
    * Upload strategy returned by create-recording.
    * `"streaming"` — server has a resumable session; engine flushes aligned
@@ -505,7 +508,10 @@ function fetchAbortError(signal: AbortSignal, err: unknown): Error {
 
 export class RecorderEngine {
   readonly opts: Required<
-    Pick<RecorderEngineOptions, "chunkIntervalMs" | "uploadUrl" | "abortUrl">
+    Pick<
+      RecorderEngineOptions,
+      "chunkIntervalMs" | "uploadUrl" | "abortUrl" | "resetUrl"
+    >
   > &
     RecorderEngineOptions;
 
@@ -617,6 +623,11 @@ export class RecorderEngine {
       abortUrl:
         options.abortUrl ??
         `${appBasePath()}/api/uploads/${options.recordingId}/abort`,
+      resetUrl:
+        options.resetUrl ??
+        (options.uploadUrl
+          ? options.uploadUrl.replace(/\/chunk(?:\?.*)?$/, "/reset-chunks")
+          : `${appBasePath()}/api/uploads/${options.recordingId}/reset-chunks`),
       ...options,
     };
   }
@@ -1149,11 +1160,17 @@ export class RecorderEngine {
     recordingId: string;
     uploadUrl: string;
     abortUrl: string;
+    resetUrl?: string;
     uploadMode?: UploadMode;
   }): void {
     this.opts.recordingId = target.recordingId;
     this.opts.uploadUrl = target.uploadUrl;
     this.opts.abortUrl = target.abortUrl;
+    this.opts.resetUrl =
+      target.resetUrl ??
+      (target.uploadUrl.endsWith("/chunk")
+        ? target.uploadUrl.slice(0, -"/chunk".length) + "/reset-chunks"
+        : `${appBasePath()}/api/uploads/${target.recordingId}/reset-chunks`);
     this.opts.uploadMode = target.uploadMode ?? "buffered";
     this.uploadGenerationId = null;
   }
@@ -1614,9 +1631,7 @@ export class RecorderEngine {
     compression: CompressionUploadMeta | null,
     signal?: AbortSignal,
   ): Promise<UploadMode> {
-    const resetUrl = `${appBasePath()}/api/uploads/${
-      this.opts.recordingId
-    }/reset-chunks`;
+    const resetUrl = this.opts.resetUrl;
     const uploadMimeType = compression?.outputMimeType || this.mimeType;
     let resetRes: Response;
     try {
@@ -2404,7 +2419,9 @@ export class RecorderEngine {
             httpStatus: String(res.status),
           },
           extra: {
-            url,
+            url: redactBrowserDiagnosticString(url, {
+              redactQueryValues: true,
+            }),
             status: res.status,
             statusText: res.statusText,
             responseBodyTail: text?.slice(0, 2000) ?? "",

package/corpus/templates/clips/app/hooks/use-video-storage-status.ts

@@ -53,10 +53,11 @@ export async function fetchVideoStorageStatus(): Promise<VideoStorageStatus> {
   };
 }
 
-export function useVideoStorageStatus() {
+export function useVideoStorageStatus(enabled = true) {
   return useQuery({
     queryKey: VIDEO_STORAGE_STATUS_KEY,
     queryFn: fetchVideoStorageStatus,
+    enabled,
     staleTime: 60_000,
   });
 }

package/corpus/templates/clips/app/routes/bug-report.done.tsx

@@ -8,6 +8,7 @@ import {
   createBugReportSubmissionMessage,
   type BugReportAgentLink,
 } from "@shared/bug-report";
+import { parseClipIntakeParams } from "@shared/clip-intake";
 import {
   IconArrowLeft,
   IconCheck,
@@ -43,6 +44,7 @@ export default function BugReportDoneRoute() {
   );
   const recordingId = params.get("recordingId")?.trim() || null;
   const returnUrl = params.get("returnUrl")?.trim() || null;
+  const intake = useMemo(() => parseClipIntakeParams(params), [params]);
 
   const recordingUrl = recordingId
     ? absoluteAppUrl(`/r/${encodeURIComponent(recordingId)}`)
@@ -55,19 +57,19 @@ export default function BugReportDoneRoute() {
     let cancelled = false;
     void (async () => {
       let agentLink: BugReportAgentLink | null = null;
-      try {
-        agentLink = (await callAction(
-          "create-recording-agent-link" as any,
-          {
+      if (!intake) {
+        try {
+          agentLink = (await callAction("create-recording-agent-link", {
             recordingId,
             ttlSeconds: BUG_REPORT_AGENT_ACCESS_TTL_SECONDS,
-          } as any,
-        )) as BugReportAgentLink;
-      } catch {
-        agentLink = null;
+          })) as BugReportAgentLink;
+        } catch (error) {
+          // The completion message keeps access explicitly unavailable when
+          // the authenticated exchange cannot be completed.
+          console.warn("[bug-report] agent link unavailable:", error);
+        }
       }
       if (cancelled) return;
-
       const message = createBugReportSubmissionMessage({
         recordingId,
         recordingUrl,
@@ -88,7 +90,7 @@ export default function BugReportDoneRoute() {
     return () => {
       cancelled = true;
     };
-  }, [embedUrl, recordingId, recordingUrl, returnUrl]);
+  }, [embedUrl, intake, recordingId, recordingUrl, returnUrl]);
 
   const copyRecordingUrl = async () => {
     if (!recordingUrl) return;

package/corpus/templates/clips/app/routes/bug-report.tsx

@@ -3,6 +3,7 @@ import {
   isBugReportSubmissionMessage,
   parseBugReportContext,
 } from "@shared/bug-report";
+import { parseClipIntakeParams } from "@shared/clip-intake";
 import { useEffect, useMemo, useRef } from "react";
 import { useLocation, useOutlet } from "react-router";
 
@@ -33,6 +34,10 @@ export default function BugReportRoute() {
     const params = new URLSearchParams(location.search);
     return parseBugReportContext(params, { allowLoose: true });
   }, [location.search]);
+  const intake = useMemo(
+    () => parseClipIntakeParams(new URLSearchParams(location.search)),
+    [location.search],
+  );
 
   const recorderWindowRef = useRef<Window | null>(null);
   const hostOrigin = originFor(
@@ -66,6 +71,7 @@ export default function BugReportRoute() {
         <section className="rounded-lg border bg-card p-4 shadow-sm sm:p-5">
           <BugReportForm
             initialContext={initialContext}
+            intake={intake}
             onRecorderOpened={(recorderWindow) => {
               recorderWindowRef.current = recorderWindow;
             }}