@agent-native/core 0.114.4 → 0.114.6

package/corpus/templates/clips/desktop/src/lib/open-meeting-join-url.ts

@@ -0,0 +1,22 @@
+import { open as openExternal } from "@tauri-apps/plugin-shell";
+
+import { resolveDesktopMeetingJoinUrl } from "./meeting-join-url";
+
+type OpenExternal = (url: string) => Promise<void>;
+
+export async function openMeetingJoinUrl(
+  joinUrl: string,
+  open: OpenExternal = openExternal,
+): Promise<void> {
+  const nativeJoinUrl = resolveDesktopMeetingJoinUrl(joinUrl);
+  if (nativeJoinUrl === joinUrl) {
+    await open(joinUrl);
+    return;
+  }
+
+  try {
+    await open(nativeJoinUrl);
+  } catch {
+    await open(joinUrl);
+  }
+}

package/corpus/templates/clips/desktop/src/lib/transcription-engine.ts

@@ -224,6 +224,35 @@ function browserLocale(): string {
   return navigator.language || "en-US";
 }
 
+function isUnavailableSelectedMicrophoneError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return /selected microphone .+ is not available/i.test(message);
+}
+
+function transcriptionStartError(
+  error: unknown,
+  selectedMicrophoneUnavailable: boolean,
+): Error {
+  if (selectedMicrophoneUnavailable) {
+    return new Error(
+      "Your selected microphone is no longer available. Clips tried your Mac's default microphone, but notes still could not start. Choose an available microphone in Clips settings, then try again.",
+    );
+  }
+
+  const message = error instanceof Error ? error.message : String(error);
+  if (
+    /screencapturekit|voiceprocessingi|microphone|audio capture|local .*capture/i.test(
+      message,
+    )
+  ) {
+    return new Error(
+      "Clips could not start local audio capture. Check that Clips has Microphone and Screen Recording access in System Settings, then try again.",
+    );
+  }
+
+  return new Error("Clips could not start local transcription. Try again.");
+}
+
 export function recordingTranscriptionLanguage(): string | null {
   return null;
 }
@@ -298,12 +327,46 @@ export async function startTranscriptionEngine(opts: {
     );
     return "whisper";
   } catch (err) {
+    let fallbackMic = opts.mic;
+    const selectedMicrophoneUnavailable =
+      Boolean(opts.mic) && isUnavailableSelectedMicrophoneError(err);
     console.warn(
       "[transcription] whisper mic+system failed, falling back to mic-only:",
       err,
     );
-    await restartTranscriptionEngine("macos-native", opts.mic);
-    return "macos-native";
+    if (selectedMicrophoneUnavailable) {
+      console.warn(
+        "[transcription] selected microphone is unavailable; retrying with the macOS default input:",
+        err,
+      );
+      try {
+        await restartTranscriptionEngine(
+          "whisper",
+          undefined,
+          captureSystem,
+          voiceProcessing,
+          emitPartials,
+        );
+        return "whisper";
+      } catch (defaultMicErr) {
+        console.warn(
+          "[transcription] default mic+system capture failed, falling back to default mic-only:",
+          defaultMicErr,
+        );
+        fallbackMic = undefined;
+      }
+    }
+    try {
+      await restartTranscriptionEngine("macos-native", fallbackMic);
+      return "macos-native";
+    } catch (fallbackErr) {
+      throw transcriptionStartError(
+        fallbackErr,
+        selectedMicrophoneUnavailable ||
+          (Boolean(opts.mic) &&
+            isUnavailableSelectedMicrophoneError(fallbackErr)),
+      );
+    }
   }
 }
 

package/corpus/templates/clips/desktop/src/overlays/meeting-notification.tsx

@@ -9,16 +9,15 @@ import { invoke } from "@tauri-apps/api/core";
 import { LogicalSize } from "@tauri-apps/api/dpi";
 import { emit, listen } from "@tauri-apps/api/event";
 import { getCurrentWindow } from "@tauri-apps/api/window";
-import { open as openExternal } from "@tauri-apps/plugin-shell";
 import { useEffect, useRef, useState } from "react";
 
-import { resolveDesktopMeetingJoinUrl } from "../lib/meeting-join-url";
 import {
   detectMeetingJoinProvider,
   joinProviderLabel,
   meetingNotificationAutoHideMs,
   type MeetingJoinProvider,
 } from "../lib/meeting-notification-timing";
+import { openMeetingJoinUrl } from "../lib/open-meeting-join-url";
 
 interface NotificationData {
   type: "calendar" | "adhoc";
@@ -51,7 +50,7 @@ const NOTIFICATION_MENU_HEIGHT = 224;
 async function openJoinUrl(url: string | null | undefined): Promise<void> {
   if (!url) return;
   try {
-    await openExternal(resolveDesktopMeetingJoinUrl(url));
+    await openMeetingJoinUrl(url);
   } catch (err) {
     console.error("[clips-tray] openJoinUrl failed:", err);
   }

package/corpus/templates/clips/server/db/schema.ts

@@ -425,6 +425,9 @@ export const meetings = table("clips_meetings", {
   })
     .notNull()
     .default("idle"),
+  shareTranscript: integer("share_transcript", { mode: "boolean" })
+    .notNull()
+    .default(false),
   summaryMd: text("summary_md").notNull().default(""),
   // JSON array of `{ text }` bullets.
   bulletsJson: text("bullets_json").notNull().default("[]"),

package/corpus/templates/clips/server/lib/public-agent-context.ts

@@ -11,6 +11,7 @@ import { getRequestURL, setResponseHeader, type H3Event } from "h3";
 import {
   buildAgentApiUrls,
   buildRecommendedFrames,
+  getAgentClipReadiness,
   CLIP_AGENT_ACCESS_TOKEN_PREFIX,
   CLIPS_AGENT_ACCESS_PARAM,
   CLIP_AGENT_CONTEXT_VERSION,
@@ -538,18 +539,24 @@ export function buildPublicAgentContext({
   const publicPageUrl = `${requestUrl.origin}${getServerAppBasePath()}/share/${encodeURIComponent(recording.id)}`;
   const isLoomSource = isLoomRecordingSource(recording);
   const isLoomEmbedBacked = isLoomEmbedBackedRecording(recording);
-  const suggestedFrames = isLoomEmbedBacked
-    ? []
-    : buildRecommendedFrames({
-        durationMs: recording.durationMs,
-        chapters,
-        segments: agentSegments,
-      }).map((frame) => ({
-        ...frame,
-        url: api.frameUrl(frame.atMs),
-      }));
+  const agentReadiness = getAgentClipReadiness(recording.status);
+  const clipIsReady = agentReadiness.state === "ready";
+  const suggestedFrames =
+    !clipIsReady || isLoomEmbedBacked
+      ? []
+      : buildRecommendedFrames({
+          durationMs: recording.durationMs,
+          chapters,
+          segments: agentSegments,
+        }).map((frame) => ({
+          ...frame,
+          url: api.frameUrl(frame.atMs),
+        }));
   const instructions = [
-    "Use transcript.segments for timestamped spoken context.",
+    ...(agentReadiness.instruction ? [agentReadiness.instruction] : []),
+    ...(clipIsReady
+      ? ["Use transcript.segments for timestamped spoken context."]
+      : []),
     ...transcriptStatusInstructions(transcript),
     ...(bugReport
       ? [
@@ -561,15 +568,17 @@ export function buildPublicAgentContext({
           "Use browserDiagnostics.consoleLogs for the redacted console stream (all levels: debug/log/info/warn/error) and browserDiagnostics.networkRequests for the fetch/XHR requests (method, sanitized URL, status, duration) captured during the recording. browserDiagnostics.consoleIssues highlights just the warnings/errors, and browserDiagnostics.failedNetworkRequests highlights failed requests.",
         ]
       : []),
-    ...(isLoomEmbedBacked
-      ? [
-          "This clip is a legacy Loom embed import; frame extraction is not available through Clips until it is reimported as a Clips-hosted video.",
-        ]
-      : [
-          "This clip is readable as both text (transcript) and images (JPEG frames) — you can hear AND see it.",
-          "To SEE the screen, GET apis.frame.urlTemplate with atMs (returns image/jpeg). Start with recommendedFrames, then fetch additional frames around transcript timestamps that matter for the task.",
-          "If you cannot load an image from a URL, you will only have the transcript — tell the user to open the clip in an image-capable agent (ChatGPT, Claude Code, Cursor, Codex) or to upload a frame image directly so you can see it.",
-        ]),
+    ...(!clipIsReady
+      ? []
+      : isLoomEmbedBacked
+        ? [
+            "This clip is a legacy Loom embed import; frame extraction is not available through Clips until it is reimported as a Clips-hosted video.",
+          ]
+        : [
+            "This clip is readable as both text (transcript) and images (JPEG frames) — you can hear AND see it.",
+            "To SEE the screen, GET apis.frame.urlTemplate with atMs (returns image/jpeg). Start with recommendedFrames, then fetch additional frames around transcript timestamps that matter for the task.",
+            "If you cannot load an image from a URL, you will only have the transcript — tell the user to open the clip in an image-capable agent (ChatGPT, Claude Code, Cursor, Codex) or to upload a frame image directly so you can see it.",
+          ]),
   ];
 
   return {
@@ -593,13 +602,14 @@ export function buildPublicAgentContext({
       hasAudio: Boolean(recording.hasAudio),
       hasCamera: Boolean(recording.hasCamera),
       status: recording.status,
+      agentReadiness,
       createdAt: recording.createdAt,
       updatedAt: recording.updatedAt,
     },
     apis: {
       context: { method: "GET", url: api.contextUrl },
       transcript: { method: "GET", url: api.transcriptUrl },
-      ...(isLoomEmbedBacked
+      ...(!clipIsReady || isLoomEmbedBacked
         ? {}
         : {
             frame: {

package/corpus/templates/clips/server/plugins/auth.ts

@@ -30,6 +30,7 @@ export default createAuthPlugin({
     "/__manifest",
     "/api/view-event",
     "/api/public-recording",
+    "/api/public-meeting",
     "/api/slack",
     "/api/agent-context.json",
     "/api/agent-transcript.json",

package/corpus/templates/clips/server/plugins/db.ts

@@ -64,6 +64,7 @@ async function retypeBooleanColumnsOnPostgres(): Promise<void> {
     ["recording_viewers", "counted_view", false],
     ["recording_viewers", "cta_clicked", false],
     ["meeting_participants", "is_organizer", false],
+    ["clips_meetings", "share_transcript", false],
   ];
   for (const [table, column, defaultTrue] of alters) {
     try {
@@ -833,6 +834,11 @@ const migrations = runMigrations(
         `CREATE UNIQUE INDEX IF NOT EXISTS recording_viewers_recording_viewer_key_unique_idx ON recording_viewers (recording_id, viewer_key)`,
       ].join("; "),
     },
+    {
+      version: 49,
+      name: "clips-meetings-share-transcript",
+      sql: `ALTER TABLE clips_meetings ADD COLUMN IF NOT EXISTS share_transcript INTEGER NOT NULL DEFAULT 0`,
+    },
   ],
   { table: "clips_migrations" },
 );

package/corpus/templates/clips/server/routes/api/agent-transcript.json.get.ts

@@ -12,7 +12,10 @@ import {
   type H3Event,
 } from "h3";
 
-import { buildAgentApiUrls } from "../../../shared/agent-context.js";
+import {
+  buildAgentApiUrls,
+  getAgentClipReadiness,
+} from "../../../shared/agent-context.js";
 import { isLoomEmbedBackedRecording } from "../../../shared/loom.js";
 import {
   applyAgentJsonHeaders,
@@ -50,6 +53,8 @@ export default defineEventHandler(async (event: H3Event) => {
     token: accessResult.access.apiToken,
   });
   const isLoomEmbedBacked = isLoomEmbedBackedRecording(recording);
+  const agentReadiness = getAgentClipReadiness(recording.status);
+  const clipIsReady = agentReadiness.state === "ready";
 
   return {
     type: "agent-native.clip.transcript",
@@ -57,11 +62,13 @@ export default defineEventHandler(async (event: H3Event) => {
       id: recording.id,
       title: recording.title,
       durationMs: recording.durationMs,
+      status: recording.status,
+      agentReadiness,
     },
     apis: {
       context: { method: "GET", url: api.contextUrl },
       transcript: { method: "GET", url: api.transcriptUrl },
-      ...(isLoomEmbedBacked
+      ...(!clipIsReady || isLoomEmbedBacked
         ? {}
         : {
             frame: {
@@ -79,6 +86,9 @@ export default defineEventHandler(async (event: H3Event) => {
       segments: agentSegments,
       segmentCount: agentSegments.length,
     },
-    instructions: transcriptStatusInstructions(transcript),
+    instructions: [
+      ...(agentReadiness.instruction ? [agentReadiness.instruction] : []),
+      ...transcriptStatusInstructions(transcript),
+    ],
   };
 });

package/corpus/templates/clips/server/routes/api/public-meeting.get.ts

@@ -0,0 +1,152 @@
+/**
+ * GET /api/public-meeting?id=<meetingId>
+ *
+ * Access-checked meeting notes for the anonymous share surface. Meeting access
+ * governs the payload; the linked transcript is an explicit, default-off part
+ * of that share and is omitted unless the meeting owner enables it.
+ */
+
+import { getSession, runWithRequestContext } from "@agent-native/core/server";
+import { resolveAccess } from "@agent-native/core/sharing";
+import { eq } from "drizzle-orm";
+import {
+  defineEventHandler,
+  getQuery,
+  setResponseHeader,
+  setResponseStatus,
+} from "h3";
+
+import {
+  normalizeTranscriptSegments,
+  parseTranscriptSegments,
+} from "../../../shared/transcript-segments.js";
+import { resolveTranscriptPresentation } from "../../../shared/transcript-status.js";
+import { getDb, schema } from "../../db/index.js";
+
+interface Bullet {
+  text: string;
+}
+
+function parseBullets(raw: string | null | undefined): Bullet[] {
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (bullet): bullet is Bullet =>
+        typeof bullet === "object" &&
+        bullet !== null &&
+        typeof bullet.text === "string",
+    );
+  } catch {
+    return [];
+  }
+}
+
+export default defineEventHandler(async (event) => {
+  setResponseHeader(event, "Cache-Control", "private, max-age=0, no-store");
+  setResponseHeader(event, "Referrer-Policy", "no-referrer");
+
+  const query = getQuery(event);
+  const meetingId = typeof query.id === "string" ? query.id : "";
+  if (!meetingId) {
+    setResponseStatus(event, 400);
+    return { error: "id is required" };
+  }
+
+  const session = await getSession(event).catch(() => null);
+  const accessContext = {
+    userEmail: session?.email,
+    orgId: session?.orgId,
+  };
+
+  return runWithRequestContext(accessContext, async () => {
+    const access = await resolveAccess("meeting", meetingId, accessContext);
+    const meeting = access?.resource;
+    if (!meeting || meeting.trashedAt) {
+      setResponseStatus(event, 404);
+      return { error: "Not found" };
+    }
+
+    const db = getDb();
+    const [participants, actionItems, transcriptRows] = await Promise.all([
+      db
+        .select({
+          email: schema.meetingParticipants.email,
+          name: schema.meetingParticipants.name,
+          isOrganizer: schema.meetingParticipants.isOrganizer,
+        })
+        .from(schema.meetingParticipants)
+        .where(eq(schema.meetingParticipants.meetingId, meetingId)),
+      db
+        .select({
+          id: schema.meetingActionItems.id,
+          text: schema.meetingActionItems.text,
+          assigneeEmail: schema.meetingActionItems.assigneeEmail,
+          completedAt: schema.meetingActionItems.completedAt,
+        })
+        .from(schema.meetingActionItems)
+        .where(eq(schema.meetingActionItems.meetingId, meetingId)),
+      meeting.shareTranscript && meeting.recordingId
+        ? db
+            .select({
+              status: schema.recordingTranscripts.status,
+              language: schema.recordingTranscripts.language,
+              fullText: schema.recordingTranscripts.fullText,
+              failureReason: schema.recordingTranscripts.failureReason,
+              segmentsJson: schema.recordingTranscripts.segmentsJson,
+              updatedAt: schema.recordingTranscripts.updatedAt,
+            })
+            .from(schema.recordingTranscripts)
+            .where(
+              eq(schema.recordingTranscripts.recordingId, meeting.recordingId),
+            )
+            .limit(1)
+        : Promise.resolve([]),
+    ]);
+
+    const transcript = transcriptRows[0] ?? null;
+    const transcriptPresentation = resolveTranscriptPresentation(transcript);
+    const transcriptSegments = transcript
+      ? normalizeTranscriptSegments({
+          segments: parseTranscriptSegments(transcript.segmentsJson),
+          fullText: transcript.fullText,
+        })
+      : [];
+    const role = access.role;
+
+    return {
+      meeting: {
+        id: meeting.id,
+        title: meeting.title,
+        scheduledStart: meeting.scheduledStart,
+        actualStart: meeting.actualStart,
+        actualEnd: meeting.actualEnd,
+        transcriptStatus: meeting.transcriptStatus,
+        summaryMd: meeting.summaryMd,
+        bullets: parseBullets(meeting.bulletsJson),
+        participants,
+        actionItems,
+        ...(meeting.shareTranscript
+          ? {
+              transcript: transcript
+                ? {
+                    status: transcriptPresentation.status,
+                    language: transcript.language,
+                    fullText: transcript.fullText,
+                    segments: transcriptSegments,
+                  }
+                : null,
+            }
+          : {}),
+      },
+      viewer: session?.email
+        ? {
+            role,
+            canEdit: role === "owner" || role === "admin" || role === "editor",
+            isOwner: role === "owner",
+          }
+        : null,
+    };
+  });
+});

package/corpus/templates/clips/shared/agent-context.ts

@@ -13,6 +13,66 @@ export const AGENT_FRAME_ENDPOINT = "/api/agent-frame.jpg";
 export const CLIP_AGENT_ACCESS_TOKEN_PREFIX = "clip-agent-context";
 export const CLIPS_AGENT_ACCESS_PARAM = AGENT_ACCESS_PARAM || "agent_access";
 
+export type AgentClipReadiness = {
+  state: "preparing" | "ready" | "failed";
+  retryAfterSeconds: number | null;
+  instruction: string | null;
+};
+
+export function getAgentClipReadiness(
+  status: string | null | undefined,
+): AgentClipReadiness {
+  if (status === "uploading") {
+    return {
+      state: "preparing",
+      retryAfterSeconds: 15,
+      instruction:
+        "This clip is still uploading and is not ready to inspect. Wait 15 seconds, then fetch agentContextUrl again. Do not open the share page, request frames, or draw conclusions until clip.status is ready.",
+    };
+  }
+
+  if (status === "processing") {
+    return {
+      state: "preparing",
+      retryAfterSeconds: 15,
+      instruction:
+        "This clip is still processing and may still be transcoding or transcribing. Wait 15 seconds, then fetch agentContextUrl again. Do not open the share page, request frames, or draw conclusions until clip.status is ready.",
+    };
+  }
+
+  return {
+    state: status === "failed" ? "failed" : "ready",
+    retryAfterSeconds: null,
+    instruction: null,
+  };
+}
+
+export function buildAgentDiscoveryPayload({
+  recordingId,
+  title,
+  status,
+  agentContextUrl,
+}: {
+  recordingId: string;
+  title: string;
+  status: string | null | undefined;
+  agentContextUrl: string;
+}) {
+  const readiness = getAgentClipReadiness(status);
+  return {
+    type: "agent-native.clip.discovery",
+    version: CLIP_AGENT_CONTEXT_VERSION,
+    clipId: recordingId,
+    title,
+    recordingStatus: status ?? "unknown",
+    agentReadiness: readiness,
+    agentContextUrl,
+    instructions:
+      readiness.instruction ??
+      "Fetch agentContextUrl for the transcript and JPEG frame URLs. Fetch the frame URLs to SEE the screen, not just read the transcript.",
+  };
+}
+
 export function agentAccessTokenResourceId(recordingId: string): string {
   if (typeof scopedAgentAccessResourceId !== "function") {
     return `${CLIP_AGENT_ACCESS_TOKEN_PREFIX}:${recordingId}`;

package/corpus/templates/clips/shared/meeting-join-url.ts

@@ -0,0 +1,31 @@
+const ZOOM_JOIN_PATH = /^\/j\/(\d+)\/?$/;
+const ZOOM_WEB_CLIENT_JOIN_PATH = /^\/wc\/(\d+)\/join\/?$/;
+
+function isZoomMeetingHost(hostname: string): boolean {
+  return hostname === "zoom.us" || hostname.endsWith(".zoom.us");
+}
+
+export function resolveNativeMeetingJoinUrl(joinUrl: string): string {
+  try {
+    const url = new URL(joinUrl);
+    if (url.protocol !== "https:" || !isZoomMeetingHost(url.hostname)) {
+      return joinUrl;
+    }
+
+    const meetingNumber =
+      ZOOM_JOIN_PATH.exec(url.pathname)?.[1] ??
+      ZOOM_WEB_CLIENT_JOIN_PATH.exec(url.pathname)?.[1];
+    if (!meetingNumber) return joinUrl;
+
+    const params = new URLSearchParams({
+      action: "join",
+      confno: meetingNumber,
+    });
+    const passcode = url.searchParams.get("pwd");
+    if (passcode) params.set("pwd", passcode);
+
+    return `zoommtg://${url.hostname}/join?${params.toString()}`;
+  } catch {
+    return joinUrl;
+  }
+}

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

@@ -82,12 +82,20 @@ pnpm action update-document --id abc123 --description "Stable guidance for what
 
 ### delete-document
 
-Delete a document and all its children recursively.
+Move a document and all its children to Trash. IDs, bodies, hierarchy, and
+database membership remain intact so the subtree can be restored.
 
 ```bash
 pnpm action delete-document --id abc123
 ```
 
+Restore the root subtree, or permanently delete it only after it is in Trash:
+
+```bash
+pnpm action restore-document --id abc123
+pnpm action permanently-delete-document --id abc123
+```
+
 ## Comments
 
 Comments are Notion/Google-Docs-style **inline comments**. Selecting text and commenting leaves the passage **highlighted inline** via a ProseMirror decoration overlay — nothing is written into the markdown body, so the document round-trips unchanged. Each thread stores the quoted text plus surrounding context (`anchorPrefix`/`anchorSuffix`) and an approximate `anchorStartOffset`, so the highlight follows the text as the document is edited, disambiguates repeated text, and degrades gracefully (the thread stays in the sidebar) when its text is deleted.

package/corpus/templates/content/AGENTS.md

@@ -146,6 +146,9 @@ cd templates/content && pnpm action <name> [args]
 | `get-content-database`                      | `--databaseId <id>` or `--documentId <id>`                                                                                                                                                         | Get a database with its description, property/option schema guidance, item pages, and computed ancestry context                                                                   |
 | `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                                                                                                                    |
+| `list-trashed-documents`                    |                                                                                                                                                                                                    | List access-filtered page roots visible in the sidebar Trash surface                                                                                                              |
+| `restore-document`                          | `--id <id>`                                                                                                                                                                                        | Restore a page and the subtree moved to Trash with it                                                                                                                             |
+| `permanently-delete-document`               | `--id <id>`                                                                                                                                                                                        | Permanently destroy a document subtree already in Trash                                                                                                                           |
 | `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-local\|builder-cms\|local-table\|notion-database] [--sourceName] [--sourceTable] [--relationshipMode items\|details] [--join <json>]` | Attach a source binding; use `items` to add more Builder rows and `details` to match a read-only local/Notion source onto existing rows                                           |
 | `list-notion-database-sources`              | `[--query <text>] [--limit <1-100>]`                                                                                                                                                               | List Notion data sources visible through the current user's OAuth connection; returns IDs/names only, never tokens                                                                |
@@ -175,7 +178,7 @@ cd templates/content && pnpm action <name> [args]
 | `reorder-document-property`                 | `--documentId <id> --propertyId <propertyId> --targetPropertyId <id> [--position before\|after]`                                                                                                   | Reorder a property definition within its database (used to reorder Blocks fields on the page)                                                                                     |
 | `set-document-discoverability`              | `--id <id> --hideFromSearch true\|false [--includeChildren true\|false]`                                                                                                                           | Hide/show an org-accessible document in Organization/search while keeping link access                                                                                             |
 | `move-document`                             | `--id <id> [--parentId] [--position]`                                                                                                                                                              | Move or reorder a document in the page tree                                                                                                                                       |
-| `delete-document`                           | `--id <id>`                                                                                                                                                                                        | Delete with recursive children                                                                                                                                                    |
+| `delete-document`                           | `--id <id>`                                                                                                                                                                                        | Move a document and its recursive children to Trash                                                                                                                               |
 
 Database views follow Notion-style tab labels. When creating or duplicating
 views in `viewConfig`, use unique default names (`Table 2`, `SEO copy 2`, etc.)

package/corpus/templates/content/actions/_content-spaces.ts

@@ -806,7 +806,11 @@ async function provisionOwnedContentSpace(
 export async function provisionSourceBackedContentSpace(
   db: Db,
   userEmail: string,
-  input: { connectionId: string; name: string },
+  input: {
+    connectionId: string;
+    name: string;
+    propertyValues?: Record<string, unknown>;
+  },
 ) {
   const connectionId = input.connectionId.trim();
   if (!connectionId) throw new Error("Local folder connection ID is required");
@@ -814,6 +818,7 @@ export async function provisionSourceBackedContentSpace(
     spaceId: sourceBackedContentSpaceId(userEmail, connectionId),
     name: input.name.trim() || "Local folder",
     kind: "source_backed",
+    propertyValues: input.propertyValues,
   });
 }
 

package/corpus/templates/content/actions/_database-row-batch.ts

@@ -151,6 +151,7 @@ export async function resolveDatabaseRowsForBatch(
         eq(schema.contentDatabaseItems.databaseId, database.id),
         rowPredicates.length === 1 ? rowPredicates[0] : or(...rowPredicates),
         isNull(schema.contentDatabases.deletedAt),
+        isNull(schema.documents.trashedAt),
       ),
     )
     .orderBy(asc(schema.contentDatabaseItems.position));
@@ -185,9 +186,21 @@ export async function renumberDatabaseRows(
   now: string,
 ) {
   const rows = await db
-    .select()
+    .select({
+      id: schema.contentDatabaseItems.id,
+      documentId: schema.contentDatabaseItems.documentId,
+    })
     .from(schema.contentDatabaseItems)
-    .where(eq(schema.contentDatabaseItems.databaseId, database.id))
+    .innerJoin(
+      schema.documents,
+      eq(schema.documents.id, schema.contentDatabaseItems.documentId),
+    )
+    .where(
+      and(
+        eq(schema.contentDatabaseItems.databaseId, database.id),
+        isNull(schema.documents.trashedAt),
+      ),
+    )
     .orderBy(asc(schema.contentDatabaseItems.position));
   if (rows.length === 0) return;