@agent-native/core-corpus 0.222.2-nightly-20261029152548 → 0.222.2

package/corpus/README.md

@@ -32,4 +32,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core-corpus/corpu
 
 ## Generated Counts
 
-- template files: 15129
+- template files: 15090

package/corpus/templates/clips/CHANGELOG.md

@@ -3,6 +3,12 @@
 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-10-29
+
+### Changed
+
+- Screenshots are available when enabled in Labs.
+
 ## 2026-10-28
 
 ### Improved
@@ -13,6 +19,7 @@ from the command menu (Cmd+K → "What's new") or from Settings.
 
 ### Fixed
 
+- Fixed the Share → Advanced popover so the Save buttons fit and the password toggle matches other switches
 - Clips desktop preserves your server choice across updates and reconnects after temporary sign-in outages.
 - Recording chapters remain reachable when the list extends below the player.
 - The Chrome extension recorder has more room and a clearer feedback link.
@@ -1600,14 +1607,4 @@ from the command menu (Cmd+K → "What's new") or from Settings.
 
 - Mobile recording pages keep videos in a 16:9 player with activity below.
 
-## 2026-07-02
-
-### Added
-
-- Private recordings can be shared with agents through temporary links without making them public.
-
-### Fixed
-
-- Recordings now wait for uploaded media to play from storage before finishing, and playback falls back when a compressed storage copy is temporarily broken.
-
 For the full list of updates, see the [changelog folder](./changelog/).

package/corpus/templates/clips/server/lib/content-clip-peer.ts

@@ -13,7 +13,18 @@ import {
 } from "@agent-native/core/server";
 import { ForbiddenError, resolveAccess } from "@agent-native/core/sharing";
 import { isEmailDerivedName } from "@agent-native/core/user-profile";
-import { and, asc, eq, isNull, sql } from "drizzle-orm";
+import {
+  and,
+  asc,
+  count,
+  eq,
+  inArray,
+  isNotNull,
+  isNull,
+  sql,
+  type SQL,
+} from "drizzle-orm";
+import { alias } from "drizzle-orm/pg-core";
 import { getQuery, getRequestHeader, getRouterParam, type H3Event } from "h3";
 import { z } from "zod";
 
@@ -29,8 +40,13 @@ import {
   CONTENT_CLIP_CLAIMS,
   CONTENT_CLIP_COMMENT_AUTHOR_CHARS,
   CONTENT_CLIP_COMMENT_PREVIEW_CHARS,
+  CONTENT_CLIP_COMMENT_TEXT_CHARS,
+  CONTENT_CLIP_MAX_COMMENT_CHARS,
   CONTENT_CLIP_MAX_COMMENT_THREADS,
+  CONTENT_CLIP_MAX_LISTED_REPLIES,
   CONTENT_CLIP_MAX_TOKEN_SECONDS,
+  CONTENT_CLIP_MAX_VIDEO_TIMESTAMP_MS,
+  CONTENT_CLIP_OPEN_THREADS_VIEW,
   CONTENT_CLIP_PUBLIC_READER,
   CONTENT_CLIP_RECORDING_TITLE_CHARS,
   CONTENT_CLIP_SCOPES,
@@ -92,10 +108,8 @@ const MAX_DOCUMENT_ID_CHARS = 256;
 const MAX_ISSUER_CHARS = 2048;
 const MAX_VIEWER_NAME_CHARS = 200;
 const ISSUED_AT_SKEW_SECONDS = 60;
-const MAX_COMMENT_CHARS = 10_000;
 const MAX_COMMENT_ID_CHARS = 128;
 const MAX_EMOJI_CHARS = 32;
-const MAX_VIDEO_TIMESTAMP_MS = 7 * 24 * 60 * 60 * 1000;
 const MAX_BODY_BYTES = 64 * 1024;
 const viewerEmailSchema = z.string().email().max(320);
 
@@ -556,50 +570,152 @@ const commentListQuerySchema = z.object({
     .transform(Number)
     .pipe(z.number().int().min(1).max(CONTENT_CLIP_MAX_COMMENT_THREADS))
     .default(CONTENT_CLIP_MAX_COMMENT_THREADS),
+  view: z.literal(CONTENT_CLIP_OPEN_THREADS_VIEW).optional(),
 });
 
 /**
  * The first `limit` thread starts by video time, as `list-comments` orders
- * them, reading one more to tell a full page from the whole list. Text and
- * names are cut to the contract's lengths. A signed-out reader's list carries
- * no commenter's email, nor a name made from one.
+ * them, reading one more to tell a full page from the whole list. The
+ * open-threads view lists only open threads, each with its replies up to the
+ * contract's bound. Text and names are cut to the contract's lengths. A
+ * signed-out reader's list carries no commenter's email, nor a name made
+ * from one.
  */
-async function listCommentThreads(peer: ContentClipPeer, limit: number) {
+async function listCommentThreads(
+  peer: ContentClipPeer,
+  limit: number,
+  openThreads: boolean,
+) {
   const { recordingId } = peer;
   const signedOut = peer.viewerEmail === null;
   await assertCommentAccess(recordingId, "read");
   const comments = schema.recordingComments;
+  const text = sql<string>`left(${comments.content}, ${
+    openThreads
+      ? CONTENT_CLIP_COMMENT_TEXT_CHARS
+      : CONTENT_CLIP_COMMENT_PREVIEW_CHARS
+  })`;
   const rows = await getDb()
     .select({
       id: comments.id,
       authorEmail: comments.authorEmail,
       authorName: comments.authorName,
-      content: sql<string>`left(${comments.content}, ${CONTENT_CLIP_COMMENT_PREVIEW_CHARS})`,
+      content: text,
       videoTimestampMs: comments.videoTimestampMs,
+      createdAt: comments.createdAt,
     })
     .from(comments)
     .where(
-      and(eq(comments.recordingId, recordingId), isNull(comments.parentId)),
+      and(
+        eq(comments.recordingId, recordingId),
+        isNull(comments.parentId),
+        openThreads ? eq(comments.resolved, false) : undefined,
+      ),
+    )
+    .orderBy(
+      asc(comments.videoTimestampMs),
+      asc(comments.createdAt),
+      asc(comments.id),
     )
-    .orderBy(asc(comments.videoTimestampMs), asc(comments.createdAt))
     .limit(limit + 1);
+  const author = <
+    Row extends { authorEmail: string; authorName: string | null },
+  >(
+    row: Row,
+  ) => {
+    const authorName =
+      signedOut && isEmailDerivedName(row.authorName, row.authorEmail)
+        ? null
+        : row.authorName;
+    return {
+      ...row,
+      authorEmail: signedOut
+        ? null
+        : row.authorEmail.slice(0, CONTENT_CLIP_COMMENT_AUTHOR_CHARS),
+      authorName:
+        authorName?.slice(0, CONTENT_CLIP_COMMENT_AUTHOR_CHARS) ?? null,
+    };
+  };
   const threads = await hydrateCommentAuthorNames(rows.slice(0, limit));
+  const truncated = rows.length > limit;
+  if (!openThreads) {
+    return {
+      comments: threads.map(({ createdAt: _createdAt, ...thread }) =>
+        author(thread),
+      ),
+      truncated,
+    };
+  }
+
+  const threadIds = threads.map((thread) => thread.id);
+  const replies = threadIds.length
+    ? await listThreadReplies(recordingId, threadIds, text)
+    : { rows: [], counts: new Map<string, number>() };
+  const repliesOf = new Map<string, unknown[]>();
+  for (const { threadId, ...reply } of await hydrateCommentAuthorNames(
+    replies.rows,
+  )) {
+    repliesOf.set(threadId, [
+      ...(repliesOf.get(threadId) ?? []),
+      author(reply),
+    ]);
+  }
   return {
-    comments: threads.map((thread) => {
-      const authorName =
-        signedOut && isEmailDerivedName(thread.authorName, thread.authorEmail)
-          ? null
-          : thread.authorName;
-      return {
-        ...thread,
-        authorEmail: signedOut
-          ? null
-          : thread.authorEmail.slice(0, CONTENT_CLIP_COMMENT_AUTHOR_CHARS),
-        authorName:
-          authorName?.slice(0, CONTENT_CLIP_COMMENT_AUTHOR_CHARS) ?? null,
-      };
-    }),
-    truncated: rows.length > limit,
+    comments: threads.map((thread) => ({
+      ...author(thread),
+      replyCount: replies.counts.get(thread.id) ?? 0,
+      replies: repliesOf.get(thread.id) ?? [],
+    })),
+    truncated,
+  };
+}
+
+/**
+ * The listed threads' replies, oldest first, from the earliest thread on and
+ * no more than the contract's bound, with how many each thread has.
+ */
+async function listThreadReplies(
+  recordingId: string,
+  threadIds: string[],
+  text: SQL<string>,
+) {
+  const comments = schema.recordingComments;
+  const root = alias(comments, "thread_start");
+  const inThreads = and(
+    eq(comments.recordingId, recordingId),
+    inArray(comments.threadId, threadIds),
+    isNotNull(comments.parentId),
+  );
+  const [rows, counts] = await Promise.all([
+    getDb()
+      .select({
+        id: comments.id,
+        threadId: comments.threadId,
+        authorEmail: comments.authorEmail,
+        authorName: comments.authorName,
+        content: text,
+        createdAt: comments.createdAt,
+      })
+      .from(comments)
+      .innerJoin(root, eq(root.id, comments.threadId))
+      .where(inThreads)
+      .orderBy(
+        asc(root.videoTimestampMs),
+        asc(root.createdAt),
+        asc(root.id),
+        asc(comments.createdAt),
+        asc(comments.id),
+      )
+      .limit(CONTENT_CLIP_MAX_LISTED_REPLIES),
+    getDb()
+      .select({ threadId: comments.threadId, replies: count() })
+      .from(comments)
+      .where(inThreads)
+      .groupBy(comments.threadId),
+  ]);
+  return {
+    rows,
+    counts: new Map(counts.map((row) => [row.threadId, Number(row.replies)])),
   };
 }
 
@@ -629,21 +745,35 @@ export async function handleContentClipComments(
       );
     }
     try {
-      return json(await listCommentThreads(peer, query.data.limit));
+      return json(
+        await listCommentThreads(
+          peer,
+          query.data.limit,
+          query.data.view === CONTENT_CLIP_OPEN_THREADS_VIEW,
+        ),
+      );
     } catch (error) {
       return forbiddenResponse(error);
     }
   });
 }
 
-const commentText = z.string().trim().min(1).max(MAX_COMMENT_CHARS);
+const commentText = z
+  .string()
+  .trim()
+  .min(1)
+  .max(CONTENT_CLIP_MAX_COMMENT_CHARS);
 const commentId = z.string().trim().min(1).max(MAX_COMMENT_ID_CHARS);
 const commentWriteSchema = z.discriminatedUnion("operation", [
   z
     .object({
       operation: z.literal("add"),
       content: commentText,
-      videoTimestampMs: z.number().int().min(0).max(MAX_VIDEO_TIMESTAMP_MS),
+      videoTimestampMs: z
+        .number()
+        .int()
+        .min(0)
+        .max(CONTENT_CLIP_MAX_VIDEO_TIMESTAMP_MS),
     })
     .strict(),
   z

package/corpus/templates/clips/shared/content-clip-contract.ts

@@ -77,10 +77,32 @@ export const CONTENT_CLIP_PLAYBACK_GRANT_SECONDS = 5 * 60;
 /**
  * The most comment threads one comment-list call returns. Content asks with
  * `?limit=<n>`, n from 1 to this, and gets the first n thread starts by video
- * time, with `truncated: true` when there are more. Replies never come back.
+ * time, with `truncated: true` when there are more. Replies come back only in
+ * the open-threads view.
  */
 export const CONTENT_CLIP_MAX_COMMENT_THREADS = 500;
 
+/**
+ * The comment list for a document's comment margin, asked for with
+ * `?view=open-threads`: open threads only, each with `createdAt`, its text
+ * cut to `CONTENT_CLIP_COMMENT_TEXT_CHARS` rather than the preview length,
+ * `replyCount`, and `replies` oldest first, each `{ id, authorEmail,
+ * authorName, content, createdAt }` cut the same way. At most
+ * `CONTENT_CLIP_MAX_LISTED_REPLIES` replies come back across the list, from
+ * the earliest thread on, so a thread whose `replies` is shorter than its
+ * `replyCount` had some held back. A Clips from before this view ignores it
+ * and answers with no `replies`.
+ */
+export const CONTENT_CLIP_OPEN_THREADS_VIEW = "open-threads";
+export const CONTENT_CLIP_COMMENT_TEXT_CHARS = 2_000;
+export const CONTENT_CLIP_MAX_LISTED_REPLIES = 500;
+
+/** The longest comment or reply Content may add or edit a Clip comment to. */
+export const CONTENT_CLIP_MAX_COMMENT_CHARS = 10_000;
+
+/** The latest moment of a video a comment from Content may sit at. */
+export const CONTENT_CLIP_MAX_VIDEO_TIMESTAMP_MS = 7 * 24 * 60 * 60 * 1000;
+
 /**
  * A listed thread start's text is cut to this many characters, and its
  * author's name and email to `CONTENT_CLIP_COMMENT_AUTHOR_CHARS`, so Content

package/corpus/templates/content/.agents/skills/document-editing/SKILL.md

@@ -301,6 +301,8 @@ On a collection page, each Blocks field tab has its own comments. Pass `fieldId`
 
 A thread can sit on a whole video instead of on text. Pass `blockId` with the video's `id` attribute from `get-document`'s content (`<video src="…" id="video-…">`), plus `fieldId` for a video in another tab. The thread quotes no text; people see it beside the video, and `list-comments` returns `block_id` and `block_type` on it. A video saved without an `id` has none to pass: give it a new unique `video-` id with `edit-document`, then comment with that id. `add-comment` refuses the id such a video goes by until then (`comment_block_id_unsaved`), because that id passes to another video when videos with its source are added or reordered. Each video's `id` is its own: when you copy a `<video>` line, give the copy a new unique `video-` id or none. An edit that gives a second video an id the page already uses is refused (`DOCUMENT_VIDEO_ID_SHARED`); a new page isn't checked, since no thread is on it yet. Videos that already share an id show none of its threads, and `add-comment` refuses that id (`comment_block_id_shared`); give the video you mean a new id with `edit-document` first. Never give it a `block_id` from `list-comments`; one no video carries may be a deleted video's, and reusing it moves that thread onto this video. A thread made before videos had ids quotes the word "Video"; on a page with exactly one video it shows on that video, and with more it stays on its quote.
 
+A Clip block (`<ClipEmbed recordingId="…" />`, behind the `content.clip-embed` flag) keeps its comments in Clips, so `list-comments` never returns them and every page holding that Clip shows the same ones. People see each open thread as its own card beside the Clip, at its moment of the video. `list-clip-comments` returns a Clip's open threads in the order of their moments, with replies; `add-clip-comment` starts a thread at `videoTimestampMs` (milliseconds from the start of the video) or replies with a `threadId` from that list; `resolve-clip-comment` resolves a thread, which Clips lets only the thread's author and the Clip's editors do (`clip_forbidden`). Writing needs comment access to the page. Clip comments take no `mentions` and no Ask AI, and Content sends no email for them. When the Clip's comments are off, every write fails with `clip_comments_disabled`, and so does reading for anyone but the Clip's owner.
+
 ```bash
 # List threads (returns anchor fields + parsed mentions)
 pnpm action list-comments --documentId abc123
@@ -325,6 +327,12 @@ pnpm action add-comment --documentId abc123 --threadId t123 --parentId c123 --co
 # Resolve / reopen the whole thread
 pnpm action update-comment --id c123 --resolved true
 pnpm action update-comment --id c123 --resolved false
+
+# A Clip's comments: list, start one at 0:42, reply, resolve
+pnpm action list-clip-comments --documentId abc123 --recordingId rec456
+pnpm action add-clip-comment --documentId abc123 --recordingId rec456 --videoTimestampMs 42000 --content "Cut this pause"
+pnpm action add-clip-comment --documentId abc123 --recordingId rec456 --threadId cc789 --content "Done"
+pnpm action resolve-clip-comment --documentId abc123 --recordingId rec456 --threadId cc789 --resolved true
 ```
 
 `--authorName` sets the comment's display name; it defaults to a name derived from the author's email.

package/corpus/templates/content/CHANGELOG.md

@@ -18,10 +18,13 @@ time from the command menu (Cmd+K → "What's new").
 
 ### Improved
 
+- A public page's link opens a read-only copy for people who aren't signed in, instead of asking them to sign in
 - An AI suggestion in a comment thread uses the same group as suggested changes in the margin: its summary, edit count, Accept all and Reject all come first, and opening it shows each edit with the usual check and X.
 
 ### Fixed
 
+- Edits to a public page reach its readers within a minute, and making it private or moving it to Trash takes it down just as fast
+- Two collections connected to the same Builder model can no longer push over each other's changes to the same entry at the same moment.
 - Restoring page history preserves text without exposing unauthorized private callout images
 - An agent's Accept on words someone is still typing in returns the suggestion to pending instead of failing with a server error
 - Opening a page you can't access goes straight to the no-access screen without a brief error first, including when you come back to it
@@ -97,6 +100,7 @@ time from the command menu (Cmd+K → "What's new").
 
 ### Improved
 
+- Shareable local-file copies open inline with document editing and sharing controls in compatible agent hosts.
 - Approval links from a connected agent, such as Claude Code, now open the review inside the app, in its own theme.
 - Tables get Header row, Header column and Fit to width in their block menu, colours for rows and columns, and menus that close the moment you press Escape.
 - The block menu turns a block into another kind, colours it and comments on it, filters as you type, and shows each action’s shortcut. It says why a locked block can’t be duplicated or deleted, and a click beside the page lets go of a selected block.

package/corpus/templates/content/actions/_clip-embed-access.ts

@@ -70,6 +70,10 @@ const FAILURES: Record<
     statusCode: 403,
     message: "Comments are turned off for this Clip",
   },
+  [CLIP_PLAYBACK_ERRORS.commentRequired]: {
+    statusCode: 403,
+    message: "Only people who can comment on the page can comment on its Clips",
+  },
   [CLIP_PLAYBACK_ERRORS.forbidden]: {
     statusCode: 403,
     message: "Clips refused this reader",
@@ -121,14 +125,39 @@ async function documentState(documentId: string) {
 export async function authorizeClipReader(
   documentId: string,
 ): Promise<ClipReader> {
+  return (await authorizeReader(documentId)).reader;
+}
+
+/**
+ * The reader Content may vouch for to Clips to comment on a Clip in this
+ * page: a signed-in reader who can comment on the page itself. A signed-out
+ * reader of a public page never can.
+ */
+export async function authorizeClipCommenter(
+  documentId: string,
+): Promise<ClipUploader> {
+  const { reader, role } = await authorizeReader(documentId);
+  if (
+    reader.kind !== "signed-in" ||
+    !role ||
+    !roleSatisfies(role, "commenter")
+  ) {
+    failClip(CLIP_PLAYBACK_ERRORS.commentRequired);
+  }
+  return reader;
+}
+
+async function authorizeReader(documentId: string) {
   const email = getRequestUserEmail();
   const readerEmail = email && !isPublicViewerOwner(email) ? email : null;
 
+  let role: Parameters<typeof roleSatisfies>[0] | null = null;
   if (readerEmail) {
     const access = await resolveDocumentAccess(documentId, {
       skipResourceBody: true,
     });
     if (!access) failClip(CLIP_PLAYBACK_ERRORS.documentNotFound);
+    role = access.role;
   }
   const state = await documentState(documentId);
   if (!state || state.trashedAt) {
@@ -147,13 +176,14 @@ export async function authorizeClipReader(
   });
   if (!enabled) failClip(CLIP_PLAYBACK_ERRORS.disabled);
 
-  return readerEmail
+  const reader: ClipReader = readerEmail
     ? {
         kind: "signed-in",
         email: readerEmail,
         name: getRequestUserName() ?? null,
       }
     : { kind: "public" };
+  return { reader, role };
 }
 
 /**

package/corpus/templates/content/actions/add-clip-comment.ts

@@ -0,0 +1,95 @@
+import { defineAction, fail } from "@agent-native/core/action";
+import { z } from "zod";
+
+import {
+  type ClipCommentWrite,
+  writeClipComment,
+} from "../server/lib/clips-peer.js";
+import {
+  CLIP_PLAYBACK_ERRORS,
+  CONTENT_CLIP_MAX_COMMENT_CHARS,
+  CONTENT_CLIP_MAX_VIDEO_TIMESTAMP_MS,
+} from "../shared/clips-peer-contract.js";
+import {
+  authorizeClipCommenter,
+  clipEmbedArgsSchema,
+  failClip,
+} from "./_clip-embed-access.js";
+
+const answerSchema = z.object({ id: z.string(), threadId: z.string() });
+
+// Coercion would read null or a blank as 0:00 and start a real thread there.
+const timestampArg = z.preprocess(
+  (value) =>
+    typeof value === "string" && value.trim() !== "" ? Number(value) : value,
+  z.number().int().min(0).max(CONTENT_CLIP_MAX_VIDEO_TIMESTAMP_MS),
+);
+
+const ONE_TARGET =
+  "Pass videoTimestampMs to start a thread or threadId to reply, not both";
+
+export default defineAction({
+  description:
+    "Comment on a Clip placed in a page: start a thread at a moment of its video (videoTimestampMs), or reply to one of its threads (threadId from list-clip-comments). The comment is saved in Clips as the caller, who must be able to comment on the page. Fails with clip_comments_disabled when the Clip's comments are off.",
+  mcpAnnotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false,
+  },
+  schema: clipEmbedArgsSchema
+    .extend({
+      content: z
+        .string()
+        .trim()
+        .min(1)
+        .max(CONTENT_CLIP_MAX_COMMENT_CHARS)
+        .describe("Comment text"),
+      videoTimestampMs: timestampArg
+        .optional()
+        .describe(
+          "Moment of the video to start a thread at, in milliseconds from its start. Omit when replying.",
+        ),
+      threadId: z
+        .string()
+        .trim()
+        .min(1)
+        .max(128)
+        .optional()
+        .describe(
+          "Id of the thread to reply to, from list-clip-comments. Omit to start a thread.",
+        ),
+    })
+    .refine(
+      (args) =>
+        (args.videoTimestampMs === undefined) !== (args.threadId === undefined),
+      ONE_TARGET,
+    ),
+  outputSchema: answerSchema,
+  run: async ({
+    documentId,
+    recordingId,
+    content,
+    videoTimestampMs,
+    threadId,
+  }) => {
+    const write: ClipCommentWrite | null =
+      threadId !== undefined
+        ? { operation: "reply", commentId: threadId, content }
+        : videoTimestampMs !== undefined
+          ? { operation: "add", content, videoTimestampMs }
+          : null;
+    if (!write) fail(ONE_TARGET, { errorCode: "clip_comment_target" });
+    const reader = await authorizeClipCommenter(documentId);
+    const result = await writeClipComment({
+      reader,
+      documentId,
+      recordingId,
+      write,
+    });
+    if (!result.ok) failClip(result.code);
+    const parsed = answerSchema.safeParse(result.body);
+    if (!parsed.success) failClip(CLIP_PLAYBACK_ERRORS.unreachable);
+    return { id: parsed.data.id, threadId: parsed.data.threadId };
+  },
+});