@agent-native/core 0.114.6 → 0.114.8

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

@@ -332,6 +332,19 @@ export { loadRunCodeToolEntries };
 export { shouldDisableRecurringJobsRuntime };
 export { finalizeClaimedAgentChatProcessRunFailure };
 
+export function resolveInteractiveAgentRunOptions(
+  options?: Pick<
+    AgentChatPluginOptions,
+    "runSoftTimeoutMs" | "runNoProgressTimeoutMs" | "durableBackgroundRuns"
+  >,
+) {
+  return {
+    runSoftTimeoutMs: options?.runSoftTimeoutMs,
+    runNoProgressTimeoutMs: options?.runNoProgressTimeoutMs,
+    durableBackgroundRuns: options?.durableBackgroundRuns,
+  };
+}
+
 export function createSerializedA2ATaskStatusWriter(
   taskId: string,
   writeStatus: (
@@ -2909,9 +2922,7 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
         model: options?.model,
         appId: options?.appId,
         apiKey: options?.apiKey,
-        runSoftTimeoutMs: options?.runSoftTimeoutMs,
-        runNoProgressTimeoutMs: options?.runNoProgressTimeoutMs,
-        durableBackgroundRuns: options?.durableBackgroundRuns,
+        ...resolveInteractiveAgentRunOptions(options),
         finalResponseGuard: options?.finalResponseGuard,
         prepareRequest: async (details) => {
           if (details.threadId && details.ownerEmail) {
@@ -3017,9 +3028,7 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
               model: options?.model,
               appId: options?.appId,
               apiKey: options?.apiKey,
-              runSoftTimeoutMs: options?.runSoftTimeoutMs,
-              runNoProgressTimeoutMs: options?.runNoProgressTimeoutMs,
-              durableBackgroundRuns: options?.durableBackgroundRuns,
+              ...resolveInteractiveAgentRunOptions(options),
               finalResponseGuard: options?.finalResponseGuard,
               prepareRequest: options?.prepareRequest,
               skipFilesContext: true,
@@ -3176,9 +3185,7 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
           model: options?.model,
           appId: options?.appId,
           apiKey: options?.apiKey,
-          runSoftTimeoutMs: options?.runSoftTimeoutMs,
-          runNoProgressTimeoutMs: options?.runNoProgressTimeoutMs,
-          durableBackgroundRuns: options?.durableBackgroundRuns,
+          ...resolveInteractiveAgentRunOptions(options),
           finalResponseGuard: options?.finalResponseGuard,
           prepareRequest: async (details) => {
             if (details.threadId && details.ownerEmail) {

package/corpus/templates/analytics/app/components/dashboard/SqlChart.tsx

@@ -26,6 +26,7 @@ import {
   type CSSProperties,
   type ReactNode,
 } from "react";
+import { createPortal } from "react-dom";
 import { Link } from "react-router";
 import {
   Area,
@@ -60,7 +61,7 @@ import {
   SelectValue,
 } from "@/components/ui/select";
 import { Skeleton } from "@/components/ui/skeleton";
-import { useChartTooltipFlip } from "@/hooks/use-chart-tooltip-flip";
+import { useChartTooltipPortalPosition } from "@/hooks/use-chart-tooltip-portal";
 
 const PAGE_SIZE_OPTIONS = [10, 25, 50, 100];
 import { createDemoChartTrendRows } from "@/lib/demo-chart-trend";
@@ -86,7 +87,7 @@ const DEFAULT_COLORS = [
 ];
 
 const CHART_TOOLTIP_WRAPPER_STYLE: CSSProperties = {
-  zIndex: 60,
+  zIndex: 9999,
   pointerEvents: "none",
 };
 
@@ -897,6 +898,7 @@ export function ChartTooltip({
   active,
   payload,
   label,
+  coordinate,
   labelFormatter,
   seriesNameFormatter,
   valueFormatter,
@@ -909,11 +911,11 @@ export function ChartTooltip({
     value?: unknown;
   }>;
   label?: unknown;
+  coordinate?: { x?: number; y?: number };
   labelFormatter?: (value: string) => string;
   seriesNameFormatter?: (value: string) => string;
   valueFormatter?: (value: number) => string;
 }) {
-  const tooltipRef = useChartTooltipFlip<HTMLDivElement>(active);
   const items = useMemo(
     () =>
       sortTooltipPayloadItems(
@@ -922,6 +924,11 @@ export function ChartTooltip({
       ),
     [payload],
   );
+  const isVisible = Boolean(active) && items.length > 0;
+  const { anchorRef, boxRef } = useChartTooltipPortalPosition(
+    isVisible,
+    coordinate,
+  );
 
   const labelText =
     label == null
@@ -930,13 +937,13 @@ export function ChartTooltip({
         ? labelFormatter(String(label))
         : String(label);
 
-  if (!active || items.length === 0) return null;
+  if (!isVisible) return null;
 
   const tooltip = (
     <div
-      ref={tooltipRef}
+      ref={boxRef}
       role="tooltip"
-      className="min-w-40 max-w-[280px] rounded-md border border-border bg-card px-3 py-2 text-xs text-foreground shadow-lg"
+      className="fixed z-[9999] min-w-40 max-w-[280px] rounded-md border border-border bg-card px-3 py-2 text-xs text-foreground shadow-lg pointer-events-none"
     >
       {labelText && (
         <div className="mb-1.5 truncate font-medium text-foreground">
@@ -971,7 +978,12 @@ export function ChartTooltip({
     </div>
   );
 
-  return tooltip;
+  return (
+    <>
+      <span ref={anchorRef} aria-hidden="true" />
+      {createPortal(tooltip, document.body)}
+    </>
+  );
 }
 
 function detectKeys(

package/corpus/templates/analytics/app/hooks/use-chart-tooltip-portal.ts

@@ -0,0 +1,60 @@
+import { useLayoutEffect, useRef } from "react";
+
+const CHART_EDGE_PADDING = 8;
+const CURSOR_OFFSET = 14;
+
+type TooltipCoordinate = { x?: number; y?: number } | undefined;
+
+/**
+ * Ancestors of a dashboard chart (the scrollable app shell, the dashboard
+ * grid's inline-size container) clip any content that overflows their box,
+ * so the tooltip content is rendered through a portal to `document.body`.
+ * Recharts positions its own tooltip wrapper by measuring that wrapper's
+ * child content size — with the real content portaled away the wrapper has
+ * no size to measure and never gets a transform, so we can't read a live
+ * position off it. Instead, position the portaled box ourselves from the
+ * `coordinate` Recharts already passes to custom tooltip content (the exact
+ * pixel the cursor is over, relative to the chart) plus the chart's own
+ * `.recharts-wrapper` rect, and clamp against that same rect so the tooltip
+ * tracks the cursor but never crosses the chart's own edges.
+ */
+export function useChartTooltipPortalPosition(
+  isVisible: boolean,
+  coordinate: TooltipCoordinate,
+) {
+  const anchorRef = useRef<HTMLSpanElement | null>(null);
+  const boxRef = useRef<HTMLDivElement | null>(null);
+
+  useLayoutEffect(() => {
+    if (!isVisible) return;
+    const anchor = anchorRef.current;
+    const box = boxRef.current;
+    if (!anchor || !box) return;
+    const chartEl = anchor.closest(".recharts-wrapper");
+    if (!chartEl) return;
+
+    const chartRect = chartEl.getBoundingClientRect();
+    const boxRect = box.getBoundingClientRect();
+
+    const pointX = chartRect.left + (coordinate?.x ?? 0);
+    const pointY = chartRect.top + (coordinate?.y ?? 0);
+
+    const minLeft = chartRect.left + CHART_EDGE_PADDING;
+    const maxLeft = chartRect.right - CHART_EDGE_PADDING - boxRect.width;
+    let left = pointX + CURSOR_OFFSET;
+    if (left > maxLeft) left = pointX - CURSOR_OFFSET - boxRect.width;
+    left = Math.min(Math.max(left, minLeft), Math.max(minLeft, maxLeft));
+
+    const minTop = chartRect.top + CHART_EDGE_PADDING;
+    const maxTop = chartRect.bottom - CHART_EDGE_PADDING - boxRect.height;
+    const top = Math.min(
+      Math.max(pointY - boxRect.height / 2, minTop),
+      Math.max(minTop, maxTop),
+    );
+
+    box.style.left = `${left}px`;
+    box.style.top = `${top}px`;
+  }, [isVisible, coordinate?.x, coordinate?.y]);
+
+  return { anchorRef, boxRef };
+}

package/corpus/templates/analytics/app/routes/chart.tsx

@@ -105,7 +105,7 @@ export default function ChartRoute() {
   }
 
   return (
-    <div className="flex h-screen w-screen flex-col overflow-hidden bg-transparent p-2">
+    <div className="flex h-screen w-screen flex-col overflow-visible bg-transparent p-2">
       {result.title && (
         <div className="mb-1 px-1 text-xs font-medium text-muted-foreground">
           {result.title}

package/corpus/templates/analytics/changelog/2026-07-20-dashboard-requests-no-longer-stall-without-progress.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-20
+---
+
+Fixed Analytics dashboard requests that stall without visible progress.

package/corpus/templates/analytics/server/plugins/agent-chat.ts

@@ -34,6 +34,11 @@ import {
 } from "../lib/real-data-actions";
 
 const ANALYTICS_BACKGROUND_RUN_SOFT_TIMEOUT_MS = 13 * 60_000;
+// A background job may legitimately spend minutes inside a provider/tool call,
+// which the shared watchdog already excludes. Outside a tool call, however,
+// silence means the model transport or worker has wedged; recover the chunk
+// promptly instead of holding the dashboard composer for the 12-minute default.
+export const ANALYTICS_BACKGROUND_RUN_NO_PROGRESS_TIMEOUT_MS = 3 * 60_000;
 
 const ANALYTICS_DATA_SOURCES_LINK = buildDeepLink({
   app: "analytics",
@@ -684,6 +689,7 @@ export default createAgentChatPlugin({
   // standard serverless request budget without orphaning the task.
   durableBackgroundRuns: true,
   runSoftTimeoutMs: ANALYTICS_BACKGROUND_RUN_SOFT_TIMEOUT_MS,
+  runNoProgressTimeoutMs: ANALYTICS_BACKGROUND_RUN_NO_PROGRESS_TIMEOUT_MS,
   connectorCatalog: [...ANALYTICS_CONNECTOR_CATALOG],
   externalAgents: {
     // Keep the direct MCP surface deliberately curated. External agents

package/corpus/templates/clips/actions/apply-rewind-extension.ts

@@ -0,0 +1,195 @@
+import { defineAction } from "@agent-native/core";
+import {
+  readAppState,
+  writeAppState,
+} from "@agent-native/core/application-state";
+import { and, eq, sql } from "drizzle-orm";
+import { z } from "zod";
+
+import { isPrivateClip } from "../app/lib/rewind-visibility.js";
+import { parseEdits, serializeEdits } from "../app/lib/timestamp-mapping.js";
+import { getDb, schema } from "../server/db/index.js";
+import {
+  getCurrentOwnerEmail,
+  ownerEmailMatches,
+} from "../server/lib/recordings.js";
+import { parseTranscriptSegments } from "../shared/transcript-segments.js";
+import { assertNoDirectRecordingShares } from "./make-recording-private-for-rewind.js";
+import {
+  rewindExtensionKey,
+  type RewindExtensionRequest,
+} from "./request-rewind-extension.js";
+
+function shiftedJsonArray(
+  raw: string | null | undefined,
+  addedMs: number,
+  fields: string[],
+): string {
+  try {
+    const parsed = JSON.parse(raw || "[]");
+    if (!Array.isArray(parsed)) return raw || "[]";
+    return JSON.stringify(
+      parsed.map((item) => {
+        if (!item || typeof item !== "object") return item;
+        const next = { ...item } as Record<string, unknown>;
+        for (const field of fields) {
+          if (typeof next[field] === "number") {
+            next[field] = Math.max(0, Math.round(next[field] + addedMs));
+          }
+        }
+        return next;
+      }),
+    );
+  } catch {
+    return raw || "[]";
+  }
+}
+
+export default defineAction({
+  description:
+    "Replace an owned Clip with an explicitly prepended local Rewind range while shifting its timestamped editor data and preserving the original-start marker.",
+  schema: z.object({
+    recordingId: z.string(),
+    requestId: z.string(),
+    preRollRecordingId: z.string(),
+    videoUrl: z.string().min(1),
+    durationMs: z.number().int().positive(),
+    addedMs: z
+      .number()
+      .int()
+      .positive()
+      .max(5 * 60_000),
+  }),
+  run: async (args) => {
+    if (args.videoUrl.startsWith("data:")) {
+      throw new Error(
+        "The combined Clip must be uploaded before it is applied.",
+      );
+    }
+    const db = getDb();
+    const ownerEmail = getCurrentOwnerEmail();
+    const [recording] = await db
+      .select()
+      .from(schema.recordings)
+      .where(
+        and(
+          eq(schema.recordings.id, args.recordingId),
+          ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
+        ),
+      );
+    const [preRoll] = await db
+      .select()
+      .from(schema.recordings)
+      .where(
+        and(
+          eq(schema.recordings.id, args.preRollRecordingId),
+          ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
+        ),
+      );
+    if (!recording || !preRoll) {
+      throw new Error("The Clip or its local Rewind pre-roll is unavailable.");
+    }
+    if (
+      !isPrivateClip(recording.visibility) ||
+      !isPrivateClip(preRoll.visibility)
+    ) {
+      throw new Error(
+        "Rewind history can only be added to a private Clip from a private pre-roll.",
+      );
+    }
+    await assertNoDirectRecordingShares(args.recordingId);
+    const key = rewindExtensionKey(args.recordingId);
+    const request = (await readAppState(key)) as RewindExtensionRequest | null;
+    if (
+      !request ||
+      request.requestId !== args.requestId ||
+      request.status !== "ready" ||
+      request.preRollRecordingId !== args.preRollRecordingId
+    ) {
+      throw new Error("The Rewind pre-roll request is not ready to apply.");
+    }
+    const expectedDuration = recording.durationMs + args.addedMs;
+    if (Math.abs(args.durationMs - expectedDuration) > 2_000) {
+      throw new Error("The combined Clip duration does not match its sources.");
+    }
+
+    const edits = parseEdits(recording.editsJson);
+    edits.trims = edits.trims.map((trim) => ({
+      ...trim,
+      startMs: trim.startMs + args.addedMs,
+      endMs: trim.endMs + args.addedMs,
+    }));
+    edits.blurs = edits.blurs.map((blur) => ({
+      ...blur,
+      startMs: blur.startMs + args.addedMs,
+      endMs: blur.endMs + args.addedMs,
+    }));
+    edits.rewindOriginalStartMs = args.addedMs;
+
+    const [transcript] = await db
+      .select()
+      .from(schema.recordingTranscripts)
+      .where(eq(schema.recordingTranscripts.recordingId, args.recordingId));
+    const shiftedTranscript = transcript
+      ? JSON.stringify(
+          parseTranscriptSegments(transcript.segmentsJson).map((segment) => ({
+            ...segment,
+            startMs: segment.startMs + args.addedMs,
+            endMs: segment.endMs + args.addedMs,
+          })),
+        )
+      : null;
+    const now = new Date().toISOString();
+
+    await db.transaction(async (tx) => {
+      await tx
+        .update(schema.recordings)
+        .set({
+          videoUrl: args.videoUrl,
+          videoFormat: "mp4",
+          durationMs: args.durationMs,
+          editsJson: serializeEdits(edits),
+          chaptersJson: shiftedJsonArray(recording.chaptersJson, args.addedMs, [
+            "startMs",
+          ]),
+          thumbnailUrl: null,
+          animatedThumbnailUrl: null,
+          updatedAt: now,
+        })
+        .where(eq(schema.recordings.id, args.recordingId));
+      if (transcript && shiftedTranscript) {
+        await tx
+          .update(schema.recordingTranscripts)
+          .set({ segmentsJson: shiftedTranscript, updatedAt: now })
+          .where(eq(schema.recordingTranscripts.recordingId, args.recordingId));
+      }
+      await tx
+        .update(schema.recordingComments)
+        .set({
+          videoTimestampMs: sql`${schema.recordingComments.videoTimestampMs} + ${args.addedMs}`,
+          updatedAt: now,
+        })
+        .where(eq(schema.recordingComments.recordingId, args.recordingId));
+      await tx
+        .update(schema.recordingReactions)
+        .set({
+          videoTimestampMs: sql`${schema.recordingReactions.videoTimestampMs} + ${args.addedMs}`,
+        })
+        .where(eq(schema.recordingReactions.recordingId, args.recordingId));
+      await tx
+        .update(schema.recordings)
+        .set({ trashedAt: now, expiresAt: now, updatedAt: now })
+        .where(eq(schema.recordings.id, args.preRollRecordingId));
+    });
+
+    const applied: RewindExtensionRequest = {
+      ...request,
+      status: "applied",
+      actualDurationMs: args.addedMs,
+      updatedAt: now,
+    };
+    await writeAppState(key, applied);
+    await writeAppState("refresh-signal", { ts: Date.now() });
+    return { recordingId: args.recordingId, request: applied };
+  },
+});

package/corpus/templates/clips/actions/delete-agent-recording-if-unpromoted.ts

@@ -0,0 +1,64 @@
+import { defineAction } from "@agent-native/core";
+import { assertAccess } from "@agent-native/core/sharing";
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import deleteRecordingPermanent from "./delete-recording-permanent.js";
+
+export default defineAction({
+  description:
+    "Delete an expired agent-created Clip only if it is still private and has not been renamed, shared, commented on, reacted to, tagged, archived, or trashed.",
+  schema: z.object({ id: z.string() }),
+  run: async ({ id }) => {
+    await assertAccess("recording", id, "editor");
+    const db = getDb();
+    const [recording] = await db
+      .select()
+      .from(schema.recordings)
+      .where(eq(schema.recordings.id, id));
+    if (!recording) return { id, deleted: true, reason: "already-missing" };
+
+    const [share, comment, reaction, tag] = await Promise.all([
+      db
+        .select({ id: schema.recordingShares.id })
+        .from(schema.recordingShares)
+        .where(eq(schema.recordingShares.resourceId, id))
+        .limit(1),
+      db
+        .select({ id: schema.recordingComments.id })
+        .from(schema.recordingComments)
+        .where(eq(schema.recordingComments.recordingId, id))
+        .limit(1),
+      db
+        .select({ id: schema.recordingReactions.id })
+        .from(schema.recordingReactions)
+        .where(eq(schema.recordingReactions.recordingId, id))
+        .limit(1),
+      db
+        .select({ id: schema.recordingTags.id })
+        .from(schema.recordingTags)
+        .where(eq(schema.recordingTags.recordingId, id))
+        .limit(1),
+    ]);
+
+    const promoted =
+      recording.visibility !== "private" ||
+      recording.titleSource === "manual" ||
+      Boolean(recording.archivedAt || recording.trashedAt) ||
+      share.length > 0 ||
+      comment.length > 0 ||
+      reaction.length > 0 ||
+      tag.length > 0;
+    if (promoted) {
+      await db
+        .update(schema.recordings)
+        .set({ expiresAt: null, updatedAt: new Date().toISOString() })
+        .where(eq(schema.recordings.id, id));
+      return { id, deleted: false, reason: "promoted" };
+    }
+
+    await deleteRecordingPermanent.run({ id });
+    return { id, deleted: true, reason: "retention-expired" };
+  },
+});

package/corpus/templates/clips/actions/get-rewind-extension-request.ts

@@ -0,0 +1,22 @@
+import { defineAction } from "@agent-native/core";
+import { readAppState } from "@agent-native/core/application-state";
+import { assertAccess } from "@agent-native/core/sharing";
+import { z } from "zod";
+
+import {
+  rewindExtensionKey,
+  type RewindExtensionRequest,
+} from "./request-rewind-extension.js";
+
+export default defineAction({
+  description: "Read the current explicit Rewind pre-roll request for a Clip.",
+  schema: z.object({ recordingId: z.string() }),
+  http: { method: "GET" },
+  run: async ({ recordingId }) => {
+    await assertAccess("recording", recordingId, "owner");
+    const request = (await readAppState(
+      rewindExtensionKey(recordingId),
+    )) as RewindExtensionRequest | null;
+    return { request };
+  },
+});

package/corpus/templates/clips/actions/get-screen-memory-status.ts

@@ -4,9 +4,25 @@ import { z } from "zod";
 
 export default defineAction({
   description:
-    "Check local Clips Screen Memory status for this machine: enabled/paused state, local storage files, and capture recency. Screen Memory is disabled by default and local-only.",
+    "Check local Clips Screen Memory status for this machine: enabled/paused state, local metadata files, and capture recency. Screen Memory is disabled by default, local-only, and does not expose media bytes or images.",
   schema: z.object({}),
   http: { method: "GET" },
   readOnly: true,
-  run: async () => readScreenMemoryStatus(),
+  run: async () => {
+    const status = await readScreenMemoryStatus();
+    return {
+      feature: status.feature,
+      localOnly: status.localOnly,
+      enabled: status.enabled,
+      paused: status.paused,
+      state: status.state,
+      captureMode: status.config.captureMode,
+      retentionHours: status.config.retentionHours,
+      captureCount: status.captureCount,
+      storageBytes: status.storageBytes,
+      oldestCaptureAt: status.oldestCaptureAt,
+      newestCaptureAt: status.newestCaptureAt,
+      note: status.note,
+    };
+  },
 });

package/corpus/templates/clips/actions/list-rewind-extension-requests.ts

@@ -0,0 +1,52 @@
+import { defineAction } from "@agent-native/core";
+import { listAppState } from "@agent-native/core/application-state";
+import { and, eq, inArray } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import {
+  getCurrentOwnerEmail,
+  ownerEmailMatches,
+} from "../server/lib/recordings.js";
+import {
+  REWIND_EXTENSION_PREFIX,
+  type RewindExtensionRequest,
+} from "./request-rewind-extension.js";
+
+export default defineAction({
+  description:
+    "List pending local Rewind pre-roll requests for the signed-in Clips Alpha app.",
+  schema: z.object({}),
+  http: { method: "GET" },
+  run: async () => {
+    const entries = await listAppState(REWIND_EXTENSION_PREFIX);
+    const staleProcessingCutoff = Date.now() - 2 * 60_000;
+    const requests = entries
+      .map((entry) => entry.value as unknown as RewindExtensionRequest)
+      .filter(
+        (request) =>
+          request &&
+          typeof request.recordingId === "string" &&
+          (request.status === "pending" ||
+            (request.status === "processing" &&
+              Date.parse(request.updatedAt) < staleProcessingCutoff)),
+      );
+    if (!requests.length) return { requests: [] };
+    const ids = [...new Set(requests.map((request) => request.recordingId))];
+    const ownerEmail = getCurrentOwnerEmail();
+    const accessible = await getDb()
+      .select({ id: schema.recordings.id })
+      .from(schema.recordings)
+      .where(
+        and(
+          ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
+          inArray(schema.recordings.id, ids),
+          eq(schema.recordings.status, "ready"),
+        ),
+      );
+    const allowed = new Set(accessible.map((row) => row.id));
+    return {
+      requests: requests.filter((request) => allowed.has(request.recordingId)),
+    };
+  },
+});

package/corpus/templates/clips/actions/make-recording-private-for-rewind.ts

@@ -0,0 +1,55 @@
+import { defineAction } from "@agent-native/core";
+import { assertAccess } from "@agent-native/core/sharing";
+import { and, eq, notExists } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+
+export const DIRECT_SHARE_REWIND_ERROR =
+  "This Clip is still shared directly with other people. Remove their access in Share before adding local Rewind history.";
+
+export async function assertNoDirectRecordingShares(
+  recordingId: string,
+): Promise<void> {
+  const [share] = await getDb()
+    .select({ id: schema.recordingShares.id })
+    .from(schema.recordingShares)
+    .where(eq(schema.recordingShares.resourceId, recordingId))
+    .limit(1);
+  if (share) throw new Error(DIRECT_SHARE_REWIND_ERROR);
+}
+
+export default defineAction({
+  description:
+    "Make an owned recording private for a Rewind extension, refusing to continue while anyone still has direct access.",
+  schema: z.object({ recordingId: z.string() }),
+  run: async ({ recordingId }) => {
+    await assertAccess("recording", recordingId, "owner");
+
+    const now = new Date().toISOString();
+    const db = getDb();
+    const [recording] = await db
+      .update(schema.recordings)
+      .set({ visibility: "private", updatedAt: now })
+      .where(
+        and(
+          eq(schema.recordings.id, recordingId),
+          notExists(
+            db
+              .select({ id: schema.recordingShares.id })
+              .from(schema.recordingShares)
+              .where(eq(schema.recordingShares.resourceId, recordingId)),
+          ),
+        ),
+      )
+      .returning({ id: schema.recordings.id });
+    if (!recording) {
+      // The conditional UPDATE is the invariant. This follow-up read only
+      // chooses the useful error message after the atomic mutation declined.
+      await assertNoDirectRecordingShares(recordingId);
+      throw new Error("This Clip is unavailable.");
+    }
+
+    return { recordingId, visibility: "private" as const };
+  },
+});

package/corpus/templates/clips/actions/query-screen-memory-context.ts

@@ -1,10 +1,10 @@
 import { defineAction } from "@agent-native/core";
-import { queryScreenMemoryContext } from "@agent-native/core/mcp-client";
+import { queryScreenMemoryForAgent } from "@agent-native/core/mcp-client";
 import { z } from "zod";
 
 export default defineAction({
   description:
-    "Search recent local Clips Screen Memory context from this machine. Returns bounded OCR/context snippets only; use get-screen-memory-status first if availability is unclear.",
+    "Search bounded local Clips Screen Memory evidence from this machine. Returns typed app-context, OCR, or transcript excerpts only when present in local files, plus coverage, gaps, segment references, jump targets, and truncation; never media bytes or images. Use get-screen-memory-status first if availability is unclear.",
   schema: z.object({
     query: z
       .string()
@@ -21,9 +21,9 @@ export default defineAction({
       .min(1)
       .max(50)
       .default(10)
-      .describe("Maximum number of context snippets to return"),
+      .describe("Maximum number of bounded local evidence items to return"),
   }),
   http: { method: "GET" },
   readOnly: true,
-  run: async (args) => queryScreenMemoryContext(args),
+  run: async (args) => queryScreenMemoryForAgent(args),
 });