@agent-native/core 0.114.5 → 0.114.7

package/corpus/templates/clips/desktop/src-tauri/src/util.rs

@@ -15,10 +15,10 @@ const POPOVER_DEFAULT_HEIGHT_LOGICAL: f64 = 520.0;
 //
 // Clips-owned recording chrome (toolbar / countdown / finalizing /
 // recording-pill) gets `NSWindow.sharingType = NSWindowSharingNone` so it does
-// not leak into the recorded video. The main popover is different: users expect
-// to screenshot it for feedback, so it stays shareable during normal idle /
-// settings use and is flipped to NSWindowSharingNone only while it is parked as
-// the hidden recording controller.
+// not leak into the recorded video. The main popover follows the same user
+// preference: private by default, shareable only when "Show Clips in screen
+// captures" is enabled. Reopening it during a recording must not silently
+// override that choice.
 // Recording-time exclusion has two effects on macOS: screen pickers don't list
 // excluded windows, and full-screen captures omit them from the compositor
 // output. This is the same mechanism Loom, 1Password, and CleanShot use to keep
@@ -183,12 +183,9 @@ pub fn set_capture_included(_window: &WebviewWindow) {
 /// immediately on anything currently on screen. Called from
 /// `set_feature_config` when the toggle flips.
 ///
-/// The popover is intentionally skipped — its sharing-type is dynamic
-/// (`set_capture_included` while shown, `set_capture_excluded` while
-/// parked at 2x2 px during recording). Both of those helpers now consult
-/// the toggle, so the next `show_popover` / `park_popover_offscreen` call
-/// picks up the new setting. Rewriting it here would clobber the parked
-/// state mid-recording.
+/// The popover follows the same preference as ordinary Clips chrome. Applying
+/// it here makes the toggle take effect immediately whether the popover is
+/// visible or parked as the 2x2 recording controller.
 ///
 /// Region-guide overlays are private recorder aids, not Clips chrome demos, so
 /// they stay excluded even when the debug toggle makes the rest visible.
@@ -198,9 +195,6 @@ pub fn reapply_capture_exclusion_to_overlays(app: &tauri::AppHandle) {
         let visible = crate::config::show_in_screen_capture(app);
         let windows = app.webview_windows();
         for (label, window) in &windows {
-            if label.as_str() == "popover" {
-                continue;
-            }
             // The meeting reminder is a notification, not Clips recording
             // chrome — keep it visible in captures regardless of the debug
             // toggle so it never gets re-excluded on a config change.

package/corpus/templates/clips/desktop/src-tauri/src/whisper_speech.rs

@@ -16,6 +16,36 @@
 //!
 use tauri::AppHandle;
 
+/// One timestamped segment produced by bounded, offline-file transcription.
+/// Timestamps are relative to the supplied audio, never to wall-clock time.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct OfflineTranscriptSegment {
+    pub start_ms: i64,
+    pub end_ms: i64,
+    pub text: String,
+}
+
+/// Transcribe already-decoded 16 kHz mono samples with the process-wide
+/// Whisper context. This is the reusable file-transcription entry point: the
+/// caller owns container decoding and the samples are never persisted here.
+///
+/// Blocking work -- call from a dedicated worker thread, not the async runtime.
+pub(crate) fn transcribe_offline_file_samples(
+    app: &AppHandle,
+    samples: &[f32],
+    language: Option<&str>,
+) -> Result<Vec<OfflineTranscriptSegment>, String> {
+    #[cfg(target_os = "macos")]
+    {
+        macos::transcribe_offline_file_samples(app, samples, language)
+    }
+    #[cfg(not(target_os = "macos"))]
+    {
+        let _ = (app, samples, language);
+        Err("local Whisper file transcription is supported on macOS only".to_owned())
+    }
+}
+
 #[tauri::command]
 pub async fn whisper_transcription_start(
     app: AppHandle,
@@ -112,6 +142,9 @@ mod macos {
     use tauri::{AppHandle, Emitter};
     use whisper_rs::{FullParams, SamplingStrategy, WhisperContext, WhisperContextParameters};
 
+    use crate::capture_audio_bus::{
+        try_subscribe, AudioSources, AudioSubscription, SubscriptionAttempt,
+    };
     use crate::native_speech::macos::{
         start_raw_mic_capture, MicVoiceProcessingMode, RawMicCapture,
     };
@@ -121,6 +154,8 @@ mod macos {
     };
     use crate::whisper_model::{ensure_model, model_file};
 
+    const MEETING_AUDIO_OWNER: &str = "meeting-whisper";
+
     /// One transcript segment with real timestamps from whisper, already
     /// offset onto the meeting timeline (ms since capture start).
     #[derive(Serialize, Clone)]
@@ -185,6 +220,31 @@ mod macos {
         Ok(())
     }
 
+    pub(super) fn transcribe_offline_file_samples(
+        app: &AppHandle,
+        samples: &[f32],
+        language: Option<&str>,
+    ) -> Result<Vec<super::OfflineTranscriptSegment>, String> {
+        const CHUNK_SAMPLES: usize = 25 * 16_000;
+
+        let ctx = context(app)?;
+        let mut state = ctx
+            .create_state()
+            .map_err(|e| format!("whisper state init failed: {e}"))?;
+        let mut segments = Vec::new();
+        for (chunk_index, chunk) in samples.chunks(CHUNK_SAMPLES).enumerate() {
+            let chunk_offset_ms = chunk_index as i64 * 25_000;
+            segments.extend(infer(&mut state, chunk, language).into_iter().map(
+                |(start_ms, end_ms, text)| super::OfflineTranscriptSegment {
+                    start_ms: chunk_offset_ms.saturating_add(start_ms),
+                    end_ms: chunk_offset_ms.saturating_add(end_ms),
+                    text,
+                },
+            ));
+        }
+        Ok(segments)
+    }
+
     // ---- resampling -------------------------------------------------------
 
     /// One linearly-interpolated 16 kHz output sample at output index `i`,
@@ -383,6 +443,12 @@ mod macos {
         /// deliberately deferred to the worker so we never allocate/compute on
         /// the realtime audio thread.
         fn push(&self, frames: &[f32]) {
+            // A bus publish may already have cloned this callback when the
+            // subscription is dropped. Refuse that final in-flight delivery
+            // once teardown has signalled the worker to stop.
+            if !self.running.load(Ordering::SeqCst) {
+                return;
+            }
             if let Ok(mut buf) = self.buf.lock() {
                 buf.extend_from_slice(frames);
             }
@@ -826,18 +892,31 @@ mod macos {
     }
 
     struct Session {
+        app: AppHandle,
         // macOS 15+ meetings use a combined SCK capture, so there is no
         // competing AVAudioEngine / VoiceProcessingIO mic input to stop.
         mic_cap: Option<RawMicCapture>,
         // System capture is optional — skipped when the user turns system
         // audio off, so neither the recording nor the transcript include it.
         sys_cap: Option<RawSckAudioCapture>,
+        // When Rewind already owns the requested SCK audio sources, meeting
+        // Whisper receives fan-out PCM through this subscription and opens no
+        // physical mic/system recorder of its own.
+        _shared_audio: Option<AudioSubscription>,
+        temporary_audio: Option<crate::screen_memory::TemporaryAudioLease>,
         mic: Arc<WhisperStream>,
         sys: Option<Arc<WhisperStream>>,
         /// Who started this session — see `SessionOwner`.
         owner: SessionOwner,
     }
 
+    impl Drop for Session {
+        fn drop(&mut self) {
+            drop(self._shared_audio.take());
+            release_temporary_audio(&self.app, self.temporary_audio.take());
+        }
+    }
+
     // SAFETY: the capture handles hold refcounted ObjC objects (already
     // `Send`); the streams are `Arc` over `Send + Sync` interiors. We only move
     // the session through the `Mutex`, never alias across threads.
@@ -936,10 +1015,80 @@ mod macos {
                     as Arc<dyn Fn(&[f32]) + Send + Sync>
             });
 
-        let combined_cap = if should_use_combined_sck_capture(
-            owner,
-            supports_sck_microphone_capture(),
-        ) {
+        // If Rewind is running visuals-only, upgrade that one physical
+        // producer before touching the bus. Off/paused Rewind returns no lease
+        // and preserves the legacy meeting capture path.
+        let temporary_audio = if owner == SessionOwner::Meeting {
+            match crate::screen_memory::acquire_temporary_audio_consumer(
+                &app,
+                MEETING_AUDIO_OWNER,
+                crate::capture_graph::CaptureConsumer::Meeting,
+                true,
+                capture_system,
+            ) {
+                Ok(lease) => lease,
+                Err(error) => {
+                    mic_stream.stop();
+                    if let Some(sys_stream) = &sys_stream {
+                        sys_stream.stop();
+                    }
+                    return Err(error);
+                }
+            }
+        } else {
+            None
+        };
+
+        // Make the shared-vs-physical choice atomically inside the bus. If a
+        // Rewind producer exists but lacks a requested source, `try_subscribe`
+        // returns a typed error and we fail closed: no combined SCK fallback,
+        // RawMicCapture, or raw system capture is opened.
+        let shared_audio = if owner == SessionOwner::Meeting {
+            let mic_for_shared = mic_stream.clone();
+            let shared_mic = Arc::new(move |samples: &[f32], sample_rate: f64| {
+                mic_for_shared.set_src_rate(sample_rate);
+                mic_for_shared.push(samples);
+            });
+            let shared_system = sys_stream.as_ref().map(|stream| {
+                let stream = stream.clone();
+                Arc::new(move |samples: &[f32], sample_rate: f64| {
+                    stream.set_src_rate(sample_rate);
+                    stream.push(samples);
+                }) as crate::capture_audio_bus::AudioCallback
+            });
+            match try_subscribe(
+                AudioSources::new(true, capture_system),
+                Some(shared_mic),
+                shared_system,
+            ) {
+                Ok(SubscriptionAttempt::Subscribed(subscription)) => Some(subscription),
+                Ok(SubscriptionAttempt::NoProducer) => {
+                    if temporary_audio.is_some() {
+                        release_temporary_audio(&app, temporary_audio);
+                        mic_stream.stop();
+                        if let Some(sys_stream) = &sys_stream {
+                            sys_stream.stop();
+                        }
+                        return Err("shared-audio-producer-unavailable-after-upgrade".into());
+                    }
+                    None
+                }
+                Err(error) => {
+                    release_temporary_audio(&app, temporary_audio);
+                    mic_stream.stop();
+                    if let Some(sys_stream) = &sys_stream {
+                        sys_stream.stop();
+                    }
+                    return Err(error.to_string());
+                }
+            }
+        } else {
+            None
+        };
+
+        let combined_cap = if shared_audio.is_none()
+            && should_use_combined_sck_capture(owner, supports_sck_microphone_capture())
+        {
             match start_raw_meeting_capture(
                 app.clone(),
                 mic_device_id.clone(),
@@ -963,7 +1112,10 @@ mod macos {
             None
         };
 
-        let (mic_cap, sys_cap) = if let Some(combined_cap) = combined_cap {
+        let (mic_cap, sys_cap) = if shared_audio.is_some() {
+            eprintln!("[whisper] using shared Rewind microphone/system PCM producer");
+            (None, None)
+        } else if let Some(combined_cap) = combined_cap {
             // Both SCK outputs are configured at 48 kHz.
             mic_stream.set_src_rate(48000.0);
             (None, Some(combined_cap))
@@ -1004,10 +1156,30 @@ mod macos {
             (Some(mic_cap), sys_cap)
         };
 
-        let mut slot = session_slot().lock().map_err(|e| e.to_string())?;
+        let mut slot = match session_slot().lock() {
+            Ok(slot) => slot,
+            Err(error) => {
+                drop(shared_audio);
+                release_temporary_audio(&app, temporary_audio);
+                mic_stream.stop();
+                if let Some(sys_stream) = &sys_stream {
+                    sys_stream.stop();
+                }
+                if let Some(mic_cap) = mic_cap {
+                    mic_cap.stop();
+                }
+                if let Some(sys_cap) = sys_cap {
+                    sys_cap.stop();
+                }
+                return Err(error.to_string());
+            }
+        };
         *slot = Some(Session {
+            app: app.clone(),
             mic_cap,
             sys_cap,
+            _shared_audio: shared_audio,
+            temporary_audio,
             mic: mic_stream,
             sys: sys_stream,
             owner,
@@ -1039,12 +1211,23 @@ mod macos {
         eprintln!("[whisper] transcription timeline reset");
     }
 
-    pub fn stop(_app: &AppHandle) {
+    fn release_temporary_audio(
+        app: &AppHandle,
+        lease: Option<crate::screen_memory::TemporaryAudioLease>,
+    ) {
+        if let Some(lease) = lease {
+            if let Err(error) = crate::screen_memory::release_temporary_audio_consumer(app, lease) {
+                eprintln!("[whisper] Rewind audio lease release failed: {error}");
+            }
+        }
+    }
+
+    pub fn stop(app: &AppHandle) {
         let session = match session_slot().lock() {
             Ok(mut slot) => slot.take(),
-            Err(_) => return,
+            Err(poisoned) => poisoned.into_inner().take(),
         };
-        let Some(session) = session else {
+        let Some(mut session) = session else {
             return;
         };
         // Signal workers to stop. They flush a final transcript after the loop.
@@ -1053,12 +1236,16 @@ mod macos {
             sys.stop();
         }
         // Stop captures so no more samples arrive while workers flush.
-        if let Some(mic_cap) = session.mic_cap {
+        if let Some(mic_cap) = session.mic_cap.take() {
             mic_cap.stop();
         }
-        if let Some(sys_cap) = session.sys_cap {
+        if let Some(sys_cap) = session.sys_cap.take() {
             sys_cap.stop();
         }
+        // Unsubscribe before a last-consumer release rotates the Rewind
+        // producer back to its persisted visuals-only mode.
+        drop(session._shared_audio.take());
+        release_temporary_audio(app, session.temporary_audio.take());
         // Wait up to 4 s for both workers to finish their final flush so
         // trailing speech is not lost when the frontend unregisters listeners.
         let deadline = Instant::now() + Duration::from_secs(4);

package/corpus/templates/clips/desktop/src-tauri/tauri.alpha.conf.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://schema.tauri.app/config/2",
+  "productName": "Clips Alpha",
+  "identifier": "com.clips.tray.alpha",
+  "bundle": {
+    "createUpdaterArtifacts": false,
+    "targets": ["app"],
+    "macOS": {
+      "minimumSystemVersion": "26.0"
+    }
+  },
+  "plugins": {
+    "updater": {
+      "active": false
+    }
+  }
+}

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

@@ -5,11 +5,6 @@ function isZoomMeetingHost(hostname: string): boolean {
   return hostname === "zoom.us" || hostname.endsWith(".zoom.us");
 }
 
-/**
- * Prefer Zoom's native URI when an HTTPS calendar link carries a meeting id.
- * Other providers and URL shapes retain their original URL as the safe
- * fallback.
- */
 export function resolveNativeMeetingJoinUrl(joinUrl: string): string {
   try {
     const url = new URL(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;
 

package/corpus/templates/content/actions/_database-utils.ts

@@ -22,7 +22,10 @@ import type {
   ContentDatabaseResponse,
 } from "../shared/api.js";
 import { favoriteDocumentIds } from "./_content-favorites.js";
-import { listContentOrganizationMemberships } from "./_content-space-access.js";
+import {
+  listContentOrganizationMemberships,
+  normalizeContentSpaceEmail,
+} from "./_content-space-access.js";
 import { getAllContentDatabaseSourceSnapshots } from "./_database-source-utils.js";
 import {
   applyFederatedOverlayValues,
@@ -81,6 +84,8 @@ export const contentDatabaseListDocumentSelection = {
   sourcePath: schema.documents.sourcePath,
   sourceRootPath: schema.documents.sourceRootPath,
   sourceUpdatedAt: schema.documents.sourceUpdatedAt,
+  trashedAt: schema.documents.trashedAt,
+  trashRootId: schema.documents.trashRootId,
   visibility: schema.documents.visibility,
   ownerEmail: schema.documents.ownerEmail,
   orgId: schema.documents.orgId,
@@ -300,9 +305,14 @@ export async function getContentDatabaseResponse(
 
   const { limit, offset } = normalizeContentDatabasePageOptions(options);
   const userEmail = getRequestUserEmail();
+  const normalizedUserEmail = userEmail
+    ? normalizeContentSpaceEmail(userEmail)
+    : null;
   const activeOrgId = getRequestOrgId();
   const authorizedOrgIds =
-    database.systemRole === "favorites" && userEmail
+    (database.systemRole === "favorites" ||
+      database.systemRole === "workspaces") &&
+    userEmail
       ? [
           ...new Set([
             ...(await listContentOrganizationMemberships(userEmail)).map(
@@ -312,6 +322,45 @@ export async function getContentDatabaseResponse(
           ]),
         ]
       : [];
+  const workspacesVisibleDocumentIds =
+    database.systemRole === "workspaces" && normalizedUserEmail
+      ? (
+          await db
+            .select({
+              documentId: schema.contentSpaceCatalogItems.documentId,
+              ownerEmail: schema.contentSpaces.ownerEmail,
+              orgId: schema.contentSpaces.orgId,
+            })
+            .from(schema.contentSpaceCatalogItems)
+            .innerJoin(
+              schema.contentSpaces,
+              eq(
+                schema.contentSpaces.id,
+                schema.contentSpaceCatalogItems.spaceId,
+              ),
+            )
+            .where(
+              and(
+                eq(
+                  schema.contentSpaceCatalogItems.catalogDatabaseId,
+                  databaseId,
+                ),
+                eq(
+                  schema.contentSpaceCatalogItems.ownerEmail,
+                  normalizedUserEmail,
+                ),
+                isNull(schema.contentSpaces.archivedAt),
+              ),
+            )
+        )
+          .filter(
+            (row) =>
+              normalizeContentSpaceEmail(row.ownerEmail) ===
+                normalizedUserEmail ||
+              (!!row.orgId && authorizedOrgIds.includes(row.orgId)),
+          )
+          .map((row) => row.documentId)
+      : null;
   const favoritesVisibleDocumentIds =
     database.systemRole === "favorites" && userEmail
       ? (
@@ -331,6 +380,7 @@ export async function getContentDatabaseResponse(
                     }),
                   ),
                 ),
+                isNull(schema.documents.trashedAt),
                 documentDiscoveryFilter({
                   userEmail,
                   orgIds: authorizedOrgIds,
@@ -351,6 +401,11 @@ export async function getContentDatabaseResponse(
       : undefined;
   const visibleItemFilter = and(
     eq(schema.contentDatabaseItems.databaseId, databaseId),
+    sql`exists (
+      select 1 from ${schema.documents}
+      where ${schema.documents.id} = ${schema.contentDatabaseItems.documentId}
+        and ${schema.documents.trashedAt} is null
+    )`,
     organizationFilesItemFilter,
     favoritesVisibleDocumentIds
       ? favoritesVisibleDocumentIds.length > 0
@@ -360,6 +415,14 @@ export async function getContentDatabaseResponse(
           )
         : sql`1 = 0`
       : undefined,
+    workspacesVisibleDocumentIds
+      ? workspacesVisibleDocumentIds.length > 0
+        ? inArray(
+            schema.contentDatabaseItems.documentId,
+            workspacesVisibleDocumentIds,
+          )
+        : sql`1 = 0`
+      : undefined,
   );
   const [itemCount] = await db
     .select({ count: sql<number>`COUNT(*)` })
@@ -388,23 +451,28 @@ export async function getContentDatabaseResponse(
                 schema.documents.id,
                 items.map((item) => item.documentId),
               ),
+              isNull(schema.documents.trashedAt),
               database.systemRole === "favorites"
                 ? favoritesVisibleDocumentIds?.length
                   ? inArray(schema.documents.id, favoritesVisibleDocumentIds)
                   : sql`1 = 0`
-                : database.systemRole === "files" && database.orgId
-                  ? and(
-                      eq(schema.documents.orgId, database.orgId),
-                      or(
-                        eq(schema.documents.visibility, "org"),
-                        eq(schema.documents.visibility, "public"),
-                      ),
-                      or(
-                        eq(schema.documents.hideFromSearch, 0),
-                        isNull(schema.documents.hideFromSearch),
-                      ),
-                    )
-                  : eq(schema.documents.ownerEmail, database.ownerEmail),
+                : database.systemRole === "workspaces"
+                  ? workspacesVisibleDocumentIds?.length
+                    ? inArray(schema.documents.id, workspacesVisibleDocumentIds)
+                    : sql`1 = 0`
+                  : database.systemRole === "files" && database.orgId
+                    ? and(
+                        eq(schema.documents.orgId, database.orgId),
+                        or(
+                          eq(schema.documents.visibility, "org"),
+                          eq(schema.documents.visibility, "public"),
+                        ),
+                        or(
+                          eq(schema.documents.hideFromSearch, 0),
+                          isNull(schema.documents.hideFromSearch),
+                        ),
+                      )
+                    : eq(schema.documents.ownerEmail, database.ownerEmail),
             ),
           )
       : [];

package/corpus/templates/content/actions/add-database-item.ts

@@ -41,6 +41,9 @@ export default defineAction({
         ),
       );
     if (!database) throw new Error(`Database "${databaseId}" not found`);
+    if (database.systemRole === "workspaces") {
+      throw new Error("Use create-content-space to add a workspace");
+    }
 
     const access = await assertAccess(
       "document",

package/corpus/templates/content/actions/connect-local-folder-source.ts

@@ -51,6 +51,7 @@ export default defineAction({
       .optional()
       .default(false)
       .describe("Create a separate private Content space for this folder"),
+    propertyValues: z.record(z.string(), z.unknown()).optional(),
     truthPolicy: truthPolicySchema.describe(
       "Whether Content, the folder, or reviewed conflict resolution is authoritative",
     ),
@@ -130,7 +131,7 @@ export default defineAction({
       const provisioned = await provisionSourceBackedContentSpace(
         db,
         userEmail,
-        { connectionId, name: label },
+        { connectionId, name: label, propertyValues: args.propertyValues },
       );
       targetSpaceId = provisioned.spaceId;
       targetDatabaseId = provisioned.filesDatabaseId;