@agent-native/core 0.84.21 → 0.84.23

package/corpus/templates/clips/app/components/library/library-grid.tsx

@@ -1,6 +1,5 @@
 import {
   getBrowserTabId,
-  sendToAgentChat,
   setClientAppState,
   useSession,
   useT,
@@ -225,6 +224,21 @@ export function LibraryGrid({
     }
   };
 
+  const moveSingle = async (
+    rec: RecordingSummary,
+    targetFolderId: string | null,
+  ) => {
+    try {
+      await moveRecording.mutateAsync({
+        id: rec.id,
+        folderId: targetFolderId,
+      });
+      toast.success(t("libraryGrid.clipsMoved", { count: 1 }));
+    } catch (err: any) {
+      toast.error(err?.message ?? t("libraryGrid.moveFailed"));
+    }
+  };
+
   const openRenameDialog = (rec: RecordingSummary) => {
     setRenamingRec(rec);
     setRenameValue(isDefaultTitle(rec.title) ? "" : (rec.title ?? ""));
@@ -385,12 +399,9 @@ export function LibraryGrid({
                       ? openRenameDialog
                       : undefined
                   }
-                  onMove={(rec) => {
-                    sendToAgentChat({
-                      message: `Move the clip "${rec.title}" (id: ${rec.id}) to a folder. Ask me which folder to move it to, or list available folders.`,
-                      background: false,
-                    });
-                  }}
+                  moveTargets={moveTargets}
+                  onMove={canMoveSelection ? moveSingle : undefined}
+                  isMovePending={moveRecording.isPending}
                   onTrash={(rec) => {
                     trashRecording.mutate(
                       { id: rec.id },

package/corpus/templates/clips/app/components/library/recording-card.tsx

@@ -24,6 +24,9 @@ import {
   DropdownMenuContent,
   DropdownMenuItem,
   DropdownMenuSeparator,
+  DropdownMenuSub,
+  DropdownMenuSubContent,
+  DropdownMenuSubTrigger,
   DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu";
 import { isDefaultTitle } from "@/hooks/use-auto-title";
@@ -32,6 +35,8 @@ import { isStaleRecordingUpload } from "@/lib/recording-status";
 import { isStorageSetupFailureReason } from "@/lib/storage-failures";
 import { cn } from "@/lib/utils";
 
+import type { BulkMoveTarget } from "./bulk-action-toolbar";
+
 function formatDuration(ms: number): string {
   const totalSeconds = Math.max(0, Math.floor(ms / 1000));
   const m = Math.floor(totalSeconds / 60);
@@ -59,7 +64,9 @@ interface RecordingCardProps {
   selectionMode?: boolean;
   onToggleSelect?: (id: string) => void;
   onShare?: (rec: RecordingSummary) => void;
-  onMove?: (rec: RecordingSummary) => void;
+  onMove?: (rec: RecordingSummary, folderId: string | null) => void;
+  moveTargets?: BulkMoveTarget[];
+  isMovePending?: boolean;
   onRename?: (rec: RecordingSummary) => void;
   onArchive?: (rec: RecordingSummary) => void;
   onTrash?: (rec: RecordingSummary) => void;
@@ -73,6 +80,8 @@ export function RecordingCard({
   onToggleSelect,
   onShare,
   onMove,
+  moveTargets = [],
+  isMovePending = false,
   onRename,
   onArchive,
   onTrash,
@@ -112,6 +121,7 @@ export function RecordingCard({
     /native recording|native fullscreen|screencapture|avconvert/i.test(
       recording.failureReason ?? "",
     );
+  const canMove = Boolean(onMove && moveTargets.length > 0);
 
   const displayThumbnail = useMemo(() => {
     if (hovered && recording.animatedThumbnailUrl)
@@ -332,10 +342,37 @@ export function RecordingCard({
                 <IconShare className="h-4 w-4 me-2" />{" "}
                 {t("recordingPage.share")}
               </DropdownMenuItem>
-              <DropdownMenuItem onSelect={() => onMove?.(recording)}>
-                <IconFolder className="h-4 w-4 me-2" />{" "}
-                {t("clipsFinalRaw.moveToFolder")}
-              </DropdownMenuItem>
+              {canMove ? (
+                <DropdownMenuSub>
+                  <DropdownMenuSubTrigger>
+                    <IconFolder className="h-4 w-4 me-2" />{" "}
+                    {t("clipsFinalRaw.moveToFolder")}
+                  </DropdownMenuSubTrigger>
+                  <DropdownMenuSubContent className="w-64">
+                    {moveTargets.map((target, index) => (
+                      <DropdownMenuItem
+                        key={target.id ?? `root-${index}`}
+                        disabled={target.disabled || isMovePending}
+                        onSelect={() => onMove?.(recording, target.id)}
+                      >
+                        <span
+                          className="truncate"
+                          style={{
+                            paddingInlineStart: (target.depth ?? 0) * 12,
+                          }}
+                        >
+                          {target.name}
+                        </span>
+                        {target.disabled && (
+                          <span className="ms-auto text-xs text-muted-foreground">
+                            {t("clipsFinalRaw.current")}
+                          </span>
+                        )}
+                      </DropdownMenuItem>
+                    ))}
+                  </DropdownMenuSubContent>
+                </DropdownMenuSub>
+              ) : null}
               {onRename ? (
                 <>
                   <DropdownMenuSeparator />

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

@@ -6,7 +6,11 @@
  * but no React state lives here — callers subscribe via `onState`, `onChunk`,
  * and `onError`.
  */
-import { appBasePath, captureClientException } from "@agent-native/core/client";
+import {
+  appBasePath,
+  captureClientException,
+  trackEvent,
+} from "@agent-native/core/client";
 import { waitForReadyRecordingAfterFinalizeError } from "@shared/finalize-recovery";
 import {
   chunkUploadUrl,
@@ -354,6 +358,19 @@ function isRetryableChunkUploadStatus(status: number): boolean {
   return RETRYABLE_CHUNK_UPLOAD_STATUSES.has(status);
 }
 
+function trackClipUploadBlockingFailure(props: Record<string, unknown>): void {
+  try {
+    trackEvent("clips_upload_blocking_failure", {
+      app: "clips",
+      template: "clips",
+      surface: "web_recorder",
+      ...props,
+    });
+  } catch {
+    // Analytics should never change recording behavior.
+  }
+}
+
 function retryDelayMs(attempt: number): number {
   return attempt === 1 ? 500 : 1500;
 }
@@ -1775,6 +1792,15 @@ export class RecorderEngine {
     }
 
     if (!res) {
+      trackClipUploadBlockingFailure({
+        stage: "chunk_upload",
+        failureKind: "no_response",
+        recordingId: this.opts.recordingId,
+        chunkIndex: index,
+        isFinal: extra.isFinal === true,
+        chunkBytes: blob.size,
+        uploadMode: this.opts.uploadMode,
+      });
       throw new Error(`Chunk ${index} upload failed: no response`);
     }
 
@@ -1791,6 +1817,20 @@ export class RecorderEngine {
         const recovered = await this.recoverReadyAfterFinalUploadError();
         if (recovered) return recovered;
       }
+      trackClipUploadBlockingFailure({
+        stage: "chunk_upload",
+        failureKind: "http_error",
+        recordingId: this.opts.recordingId,
+        chunkIndex: index,
+        isFinal: extra.isFinal === true,
+        httpStatus: res.status,
+        statusText: res.statusText,
+        chunkBytes: blob.size,
+        uploadMode: this.opts.uploadMode,
+        finalUploadRecoveryAttempted:
+          extra.isFinal === true &&
+          this.isFinalUploadRecoveryCandidate(res.status, err),
+      });
       // Capture rich context to Sentry BEFORE throwing — when this hits
       // production we want enough breadcrumbs in the event to debug a
       // "Builder.io upload failed (500)" without re-running the upload.

package/corpus/templates/clips/changelog/2026-07-01-move-to-folder-now-opens-folder-choices-directly-instead-of.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-01
+---
+
+Move to folder now opens folder choices directly instead of starting an agent chat.

package/corpus/templates/clips/changelog/2026-07-01-shared-clips-now-start-playing-and-scrub-instantly-instead-o.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-01
+---
+
+Shared clips now start playing and scrub instantly instead of buffering — recordings are made seekable on upload, and you can repair older clips

package/corpus/templates/clips/chrome-extension/public/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 3,
   "name": "Agent-Native Clips",
   "short_name": "Clips",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Start Clips recordings from Chrome, capture optional diagnostics, and preview Clips links on GitHub.",
   "minimum_chrome_version": "116",
   "action": {

package/corpus/templates/clips/server/lib/video-remux.ts

@@ -0,0 +1,222 @@
+/**
+ * Make recorded video seekable so browsers can start playback immediately and
+ * scrub without re-buffering the whole file.
+ *
+ * Two problems this fixes, both produced by `MediaRecorder` output:
+ *   - MP4: the `moov` metadata atom is written AFTER `mdat`, so a player must
+ *     download the entire file before it can start / seek. We relocate it with
+ *     the pure-TypeScript {@link applyFaststart} (no ffmpeg needed).
+ *   - WebM: MediaRecorder emits a "live" stream with no Cues (seek index) and an
+ *     unknown Segment duration, so Chrome refuses to honor `currentTime = X`
+ *     seeks and has to scan/download to move around. A cheap `ffmpeg -c copy`
+ *     remux rewrites the container with a SeekHead + Cues index and a real
+ *     duration — no re-encode, so it's fast and lossless.
+ *
+ * Everything here is best-effort: on any failure (ffmpeg missing, bad input,
+ * timeout) we return the ORIGINAL bytes with `changed: false`, so callers never
+ * regress relative to uploading the raw recording.
+ */
+
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { applyFaststart, hasPlayableMp4Metadata } from "./faststart.js";
+
+const REMUX_TIMEOUT_MS = 120_000;
+const STDERR_LIMIT = 16 * 1024;
+const MAX_CONCURRENT_REMUXES = 2;
+// EBML magic that every valid Matroska/WebM file starts with.
+const EBML_MAGIC = [0x1a, 0x45, 0xdf, 0xa3];
+
+const requireFromThisFile = createRequire(import.meta.url);
+let cachedFfmpegStaticPath: string | null | undefined;
+let activeRemuxes = 0;
+const remuxWaiters: Array<() => void> = [];
+
+export type VideoFormat = "webm" | "mp4";
+
+export interface SeekableResult {
+  /** The seekable bytes, or the original bytes when nothing changed. */
+  bytes: Uint8Array;
+  /** True when the returned bytes differ from the input. */
+  changed: boolean;
+}
+
+function ffmpegCommand(): string {
+  if (process.env.FFMPEG_PATH) return process.env.FFMPEG_PATH;
+  return resolveFfmpegStaticPath() ?? "ffmpeg";
+}
+
+function resolveFfmpegStaticPath(): string | null {
+  if (cachedFfmpegStaticPath !== undefined) return cachedFfmpegStaticPath;
+  try {
+    const resolved = requireFromThisFile("ffmpeg-static");
+    cachedFfmpegStaticPath =
+      typeof resolved === "string" && resolved && existsSync(resolved)
+        ? resolved
+        : null;
+  } catch {
+    cachedFfmpegStaticPath = null;
+  }
+  return cachedFfmpegStaticPath;
+}
+
+/** Whether a server-side ffmpeg binary is resolvable. */
+export function isFfmpegAvailable(): boolean {
+  return Boolean(process.env.FFMPEG_PATH) || resolveFfmpegStaticPath() !== null;
+}
+
+function startsWithMagic(bytes: Uint8Array, magic: number[]): boolean {
+  if (bytes.byteLength < magic.length) return false;
+  for (let i = 0; i < magic.length; i++) {
+    if (bytes[i] !== magic[i]) return false;
+  }
+  return true;
+}
+
+async function runFfmpeg(args: string[]): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    const child = spawn(ffmpegCommand(), args, {
+      stdio: ["ignore", "ignore", "pipe"],
+    });
+    let stderr = "";
+    const timeout = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error(`ffmpeg remux timed out\n${stderr}`));
+    }, REMUX_TIMEOUT_MS);
+
+    child.stderr?.on("data", (chunk: Buffer) => {
+      stderr = (stderr + chunk.toString("utf8")).slice(-STDERR_LIMIT);
+    });
+    child.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(new Error(`${err.message}\n${stderr}`));
+    });
+    child.on("close", (code) => {
+      clearTimeout(timeout);
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`ffmpeg exited with code ${code}\n${stderr}`));
+    });
+  });
+}
+
+async function withRemuxSlot<T>(fn: () => Promise<T>): Promise<T> {
+  if (activeRemuxes >= MAX_CONCURRENT_REMUXES) {
+    await new Promise<void>((resolve) => remuxWaiters.push(resolve));
+  }
+  activeRemuxes += 1;
+  try {
+    return await fn();
+  } finally {
+    activeRemuxes = Math.max(0, activeRemuxes - 1);
+    remuxWaiters.shift()?.();
+  }
+}
+
+/**
+ * Rewrite a WebM/Matroska file with a SeekHead + Cues index and a real
+ * duration via a lossless `ffmpeg -c copy` remux. Returns the original bytes
+ * unchanged when ffmpeg is unavailable, the input isn't WebM, or anything
+ * goes wrong.
+ */
+export async function remuxWebmToSeekable(
+  mediaBytes: Uint8Array,
+): Promise<SeekableResult> {
+  const unchanged: SeekableResult = { bytes: mediaBytes, changed: false };
+
+  if (mediaBytes.byteLength === 0) return unchanged;
+  if (!startsWithMagic(mediaBytes, EBML_MAGIC)) return unchanged;
+  if (!isFfmpegAvailable()) return unchanged;
+
+  const dir = await mkdtemp(join(tmpdir(), "clips-remux-"));
+  const inputPath = join(dir, "input.webm");
+  const outputPath = join(dir, "output.webm");
+
+  try {
+    await writeFile(inputPath, mediaBytes);
+    await withRemuxSlot(() =>
+      runFfmpeg([
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-nostdin",
+        "-y",
+        // Regenerate presentation timestamps so a live MediaRecorder stream
+        // gets a coherent, seekable timeline in the remuxed output.
+        "-fflags",
+        "+genpts",
+        "-i",
+        inputPath,
+        // Stream-copy every track: no re-encode, so this stays fast + lossless.
+        "-map",
+        "0",
+        "-c",
+        "copy",
+        "-f",
+        "webm",
+        outputPath,
+      ]),
+    );
+
+    const info = await stat(outputPath).catch(() => null);
+    if (!info || info.size === 0) return unchanged;
+
+    const out = new Uint8Array(await readFile(outputPath));
+    // Validate the muxer actually produced a WebM before trusting it.
+    if (!startsWithMagic(out, EBML_MAGIC)) return unchanged;
+
+    return { bytes: out, changed: true };
+  } catch (err) {
+    console.warn("[video-remux] webm remux failed, keeping original", {
+      err: err instanceof Error ? err.message : String(err),
+    });
+    return unchanged;
+  } finally {
+    await rm(dir, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+/**
+ * Make an MP4 start-playable by moving its `moov` atom ahead of `mdat`. Pure
+ * TypeScript — no ffmpeg. Returns the original bytes when already faststarted
+ * or when the result would fail metadata validation.
+ */
+export function faststartMp4(mediaBytes: Uint8Array): SeekableResult {
+  if (mediaBytes.byteLength === 0) return { bytes: mediaBytes, changed: false };
+  try {
+    const out = applyFaststart(mediaBytes);
+    if (out === mediaBytes) return { bytes: mediaBytes, changed: false };
+    if (!hasPlayableMp4Metadata(out)) {
+      return { bytes: mediaBytes, changed: false };
+    }
+    return { bytes: out, changed: true };
+  } catch (err) {
+    console.warn("[video-remux] mp4 faststart failed, keeping original", {
+      err: err instanceof Error ? err.message : String(err),
+    });
+    return { bytes: mediaBytes, changed: false };
+  }
+}
+
+/**
+ * Make recorded media seekable based on its container format. Dispatches to
+ * {@link faststartMp4} for MP4 and {@link remuxWebmToSeekable} for WebM.
+ * Always resolves; unknown formats and failures return the input unchanged.
+ */
+export async function makeSeekable(input: {
+  mediaBytes: Uint8Array;
+  videoFormat: VideoFormat;
+}): Promise<SeekableResult> {
+  if (input.videoFormat === "mp4") return faststartMp4(input.mediaBytes);
+  if (input.videoFormat === "webm") {
+    return remuxWebmToSeekable(input.mediaBytes);
+  }
+  return { bytes: input.mediaBytes, changed: false };
+}

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/chunk.post.ts

@@ -19,6 +19,7 @@ import {
 } from "@agent-native/core/application-state";
 import { getActiveFileUploadProvider } from "@agent-native/core/file-upload";
 import { runWithRequestContext } from "@agent-native/core/server";
+import { track } from "@agent-native/core/tracking";
 import { normalizeChunkUploadNumber } from "@shared/recording-core.js";
 import { MAX_UPLOAD_BYTES as MAX_RECORDING_UPLOAD_BYTES } from "@shared/upload-limits.js";
 import { and, eq } from "drizzle-orm";
@@ -95,6 +96,26 @@ function stateNumber(
   return typeof raw === "number" && Number.isFinite(raw) ? raw : undefined;
 }
 
+function trackUploadBlockingFailure(
+  ownerEmail: string,
+  properties: Record<string, unknown>,
+): void {
+  try {
+    track(
+      "clips_upload_blocking_failure",
+      {
+        app: "clips",
+        template: "clips",
+        surface: "server_upload",
+        ...properties,
+      },
+      { userId: ownerEmail },
+    );
+  } catch {
+    // Best-effort analytics must never change upload behavior.
+  }
+}
+
 export default defineEventHandler(async (event: H3Event) => {
   const recordingId = getRouterParam(event, "recordingId");
   if (!recordingId) {
@@ -189,6 +210,7 @@ export default defineEventHandler(async (event: H3Event) => {
         isFinal,
         mimeType,
         query,
+        ownerEmail,
       );
     }
 
@@ -507,6 +529,13 @@ export default defineEventHandler(async (event: H3Event) => {
             hasCamera: committed.hasCamera,
           };
         }
+        trackUploadBlockingFailure(ownerEmail, {
+          stage: "finalize_recording",
+          failureKind: "finalize_error",
+          recordingId,
+          uploadMode: "buffered",
+          errorMessage: err instanceof Error ? err.message : String(err),
+        });
         await db
           .update(schema.recordings)
           .set({
@@ -566,6 +595,7 @@ async function handleResumableChunk(
   isFinal: boolean,
   mimeType: string,
   query: Record<string, unknown>,
+  ownerEmail: string,
 ) {
   const uploadProvider = getActiveFileUploadProvider();
   console.log(
@@ -681,6 +711,13 @@ async function handleResumableChunk(
     return { ok: true, finalized: true, ...result };
   } catch (err) {
     console.error(`[resumable-chunk-${recordingId}] finalize failed:`, err);
+    trackUploadBlockingFailure(ownerEmail, {
+      stage: "finalize_recording",
+      failureKind: "finalize_error",
+      recordingId,
+      uploadMode: "resumable",
+      errorMessage: err instanceof Error ? err.message : String(err),
+    });
     setResponseStatus(event, 500);
     return {
       ok: false,

package/corpus/templates/content/.agents/skills/frontend-design/SKILL.md

@@ -53,6 +53,8 @@ Default to Apple/Linear-level restraint: make the primary workflow obvious, then
 - **Visual assets**: Websites, games, and object-focused pages need real or generated media when images help users understand the subject.
 - **Responsive fit**: Text must not overflow buttons, cards, tabs, sidebars, or fixed-format tools. Use stable dimensions for boards, grids, toolbars, and counters.
 
+**Beat convergence, not just defaults.** You sample toward the "on-distribution" center, so naming what to avoid is not enough: every "don't" needs a "do", or you converge on the next safe option (ban Inter and you reach for Roboto; ban purple gradients and you reach for Space Grotesk + a teal accent on every screen). Commit to one named direction, pair any reference with the reason it fits ("Linear: the quiet confidence of its spacing" — a bare "Linear" collapses back to the average), and match implementation effort to the vision: maximalist wants elaborate motion and effects, minimal wants restraint and precise spacing. When building on an existing app, inspect its tokens/type/components first and treat any drift back to a default as a missing token to pin, not something to re-prompt.
+
 ## Agent-Native UI Rules
 
 - Agent-native apps use React, Vite, Tailwind CSS, shadcn/ui, and `@tabler/icons-react`.

package/corpus/templates/content/AGENTS.md

@@ -108,7 +108,10 @@ cd templates/content && pnpm action <name> [args]
 | `list-local-component-files`                |                                                                                                                                                                | List registered local MDX component source files                                                                                        |
 | `write-local-component-file`                | `--workspaceId <id> --path <relative-component-path> --content <source>`                                                                                       | Create or update a file in a registered local `components/` folder                                                                      |
 | `create-content-database`                   | `[--documentId <id>] [--parentId <id>] [--title <text>]`                                                                                                       | Create a database page or convert an existing page into a database                                                                      |
+| `create-inline-content-database`            | `--hostDocumentId <id> [--title <text>]`                                                                                                                       | Create a database owned by an inline database block in the host document                                                                |
 | `get-content-database`                      | `--databaseId <id>` or `--documentId <id>`                                                                                                                     | Get a database table with property schema and item pages                                                                                |
+| `list-trashed-content-databases`            |                                                                                                                                                                | List soft-deleted databases visible in the sidebar Trash surface                                                                        |
+| `restore-content-database`                  | `--databaseId <id>`                                                                                                                                            | Restore a soft-deleted database from the sidebar Trash surface                                                                          |
 | `get-content-database-source`               | `--databaseId <id>` or `--documentId <id>`                                                                                                                     | Inspect local/no-source or source-backed status, mappings, row identity, freshness, and change sets                                     |
 | `attach-content-database-source`            | `--databaseId <id>` or `--documentId <id> [--sourceType mock\|builder-cms] [--sourceName] [--sourceTable] [--relationshipMode items\|details] [--join <json>]` | Attach a source binding; use `items` to add more rows and `details` to match a source onto existing rows                                |
 | `change-content-database-source-role`       | `--databaseId <id>` or `--documentId <id> --sourceId <id> --relationshipMode items\|details [--join <json>]`                                                   | Change an attached source between adding rows and adding matched detail columns without removing the source                             |
@@ -569,9 +572,10 @@ columns updates that row page's grouping property through
 multi-select, users can add a new board group from the board itself; this
 appends a new option to the grouped property definition.
 Use
-`create-content-database`, `get-content-database`,
-`add-database-item`, `duplicate-database-item`, `duplicate-database-items`,
-`delete-database-items`, `move-database-item`,
+`create-content-database`, `create-inline-content-database`,
+`get-content-database`, `list-trashed-content-databases`,
+`restore-content-database`, `add-database-item`, `duplicate-database-item`,
+`duplicate-database-items`, `delete-database-items`, `move-database-item`,
 `update-content-database-view`, `list-document-properties`,
 `configure-document-property`, `set-document-property`,
 `duplicate-document-property`, and `delete-document-property`; do not edit

package/corpus/templates/content/README.md

@@ -1,46 +1,34 @@
 # Content
 
-Open-source Obsidian for MDX, built with the agent-native framework. Edit local
-Markdown/MDX files, generate rich interactive custom blocks, and organize
-hierarchical pages with an AI agent.
+Open-source Obsidian for MDX — an agent-native, local-file document workspace and
+a self-hostable alternative to Notion and Obsidian. Edit local Markdown/MDX files,
+build Notion-style databases, and write with an AI agent.
+
+**Live app: [content.agent-native.com](https://content.agent-native.com)**
+
+Open a doc and ask "rewrite this paragraph to be more concise" or "create a page
+called Q4 Planning with sub-pages for Goals, Metrics, and Risks" — the same result
+whether you do it yourself or ask. Documents can live in your SQL database or as
+local Markdown/MDX files.
 
 ## Features
 
-- Hierarchical pages (unlimited nesting)
-- Rich text editor (Tiptap) with slash commands
-- Favorites for quick access
-- Full-text search
-- Local Markdown/MDX file editing
-- Custom interactive MDX blocks from local components
-- Agent can create, read, update, and search documents
-- Auto-save with debouncing
-- Dark/light theme
+- Rich-text editor (Tiptap) with slash commands and hierarchical pages.
+- Notion-style databases with table, board, calendar, gallery, and timeline views.
+- Local Markdown/MDX file editing plus custom interactive MDX components.
+- Inline comments, version history, and full-text search.
+- Private-by-default sharing with per-user / per-org grants and public pages.
+- Optional Notion and Builder.io sync.
 
-## Getting Started
+## Develop locally
+
+Scaffold your own copy and run it:
 
 ```bash
+npx @agent-native/core@latest create my-content --standalone --template content
+cd my-content
 pnpm install
 pnpm dev
 ```
 
-Open http://localhost:8080 and create your first page.
-
-## Data
-
-Documents are stored in the app's SQL database. Local development defaults to SQLite at `data/app.db`; deployed apps should set `DATABASE_URL` to a persistent SQL database. The agent should use content actions for normal document operations and reserve `db-query` / `db-exec` for inspection or maintenance.
-
-## Enable Builder live writes
-
-Connect Builder through the existing Builder Connect flow, the same connection used by the AI assistant. Once connected, Content resolves the key automatically for the user, or for org owners/admins through the org connection. There is no separate key entry. In local development, `BUILDER_PRIVATE_KEY` and `BUILDER_PUBLIC_KEY` in `.env.local` also work; see `DEVELOPING.md` for local env opt-in details.
-
-Live writes are only allowed for the safe write model `agent-native-blog-article-test` (`BUILDER_CMS_SAFE_WRITE_MODEL`). Other Builder models stay read-only by design.
-
-Write access is an intentional per-source choice from the source panel selector. Sources start at `read_only`, can move to `stage_only` to push approved changes as Builder autosave revisions, and can move to `publish_updates` for state-preserving live writes. Autosave staging stays quiet; update-in-place and publish writes trigger Builder webhooks so downstream rebuilds can run.
-
-In `publish_updates`, Content PATCHes the Builder entry in place and preserves its current publication state: published entries stay published and drafts stay draft. Content never sends a `published` field, so a normal content push cannot publish or unpublish. Builder merges the field changes and preserves the entry envelope, including scheduling and targeting.
-
-Publication transitions are explicit per-row choices in the review/diff, only when the source enables **Allow publish/unpublish per item**. Publishing a draft or unpublishing a published entry is never a bulk default, and unpublish requires confirmation because it takes live content down. New Builder entries are created as drafts.
-
-**Push all approved (N)** runs approved rows in a concurrency-capped batch. It continues after individual errors, reports per-item `succeeded`, `blocked`, or `failed` status, and can be resumed because already-succeeded items are skipped.
-
-Before each write, Content reads the target's current state from Builder. A write blocks if the entry changed or was deleted since the diff, or if a requested publish/unpublish transition no longer matches the real Builder state. Body diffs remain non-executable for now; they are planned for a later slice.
+Full docs: [agent-native.com/docs/template-content](https://agent-native.com/docs/template-content).

package/corpus/templates/content/actions/list-trashed-content-databases.ts

@@ -33,6 +33,7 @@ export default defineAction({
         ownerDocumentId: schema.contentDatabases.ownerDocumentId,
         deletedAt: schema.contentDatabases.deletedAt,
         documentTitle: schema.documents.title,
+        documentParentId: schema.documents.parentId,
       })
       .from(schema.contentDatabases)
       .innerJoin(
@@ -80,6 +81,9 @@ export default defineAction({
         documentId: row.documentId,
         ownerDocumentId: row.ownerDocumentId,
         deletedAt: row.deletedAt!,
+        canPermanentlyDelete:
+          row.ownerDocumentId === null ||
+          row.documentParentId !== row.ownerDocumentId,
       })),
     };
   },