@agent-native/core 0.91.1 → 0.92.0

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

@@ -16,8 +16,8 @@ use crate::util::{
 };
 
 const MEETING_NOTIFICATION_LABEL: &str = "meeting-notif";
-const NOTIFICATION_W_LOGICAL: u32 = 420;
-const NOTIFICATION_H_LOGICAL: u32 = 148;
+const NOTIFICATION_W_LOGICAL: u32 = 440;
+const NOTIFICATION_H_LOGICAL: u32 = 120;
 const NOTIFICATION_TOP_MARGIN_LOGICAL: u32 = 44;
 const NOTIFICATION_RIGHT_MARGIN_LOGICAL: u32 = 24;
 
@@ -109,6 +109,38 @@ pub fn take_pending_meeting_notification(app: AppHandle) -> Result<Option<Value>
     Ok(pending.take())
 }
 
+fn format_time_range_subtitle(
+    scheduled_start: Option<&str>,
+    scheduled_end: Option<&str>,
+    starts_in_secs: i64,
+) -> String {
+    let Some(start_str) = scheduled_start else {
+        return fallback_starts_subtitle(starts_in_secs);
+    };
+    let Ok(start) = chrono::DateTime::parse_from_rfc3339(start_str) else {
+        return fallback_starts_subtitle(starts_in_secs);
+    };
+    let local_start = start.with_timezone(&chrono::Local);
+    let start_label = local_start.format("%-I:%M %p").to_string();
+    if let Some(end_str) = scheduled_end {
+        if let Ok(end) = chrono::DateTime::parse_from_rfc3339(end_str) {
+            let end_label = end.with_timezone(&chrono::Local).format("%-I:%M %p");
+            return format!("{start_label} - {end_label}");
+        }
+    }
+    start_label
+}
+
+fn fallback_starts_subtitle(starts_in_secs: i64) -> String {
+    if starts_in_secs <= 0 {
+        "Started".to_string()
+    } else if starts_in_secs < 90 {
+        format!("Starts in {}s", starts_in_secs)
+    } else {
+        format!("Starts in {} min", (starts_in_secs / 60).max(1))
+    }
+}
+
 #[tauri::command]
 pub async fn notify_meeting_starting(
     app: AppHandle,
@@ -116,18 +148,30 @@ pub async fn notify_meeting_starting(
     title: String,
     starts_in_secs: i64,
     join_url: Option<String>,
+    scheduled_start: Option<String>,
+    scheduled_end: Option<String>,
+    platform: Option<String>,
     auto_start: Option<bool>,
+    notification_type: Option<String>,
 ) -> Result<(), String> {
-    let pretty_in = if starts_in_secs <= 0 {
-        "now".to_string()
-    } else if starts_in_secs < 90 {
-        format!("in {}s", starts_in_secs)
+    let kind = notification_type
+        .as_deref()
+        .map(str::trim)
+        .filter(|s| !s.is_empty())
+        .unwrap_or("calendar");
+    let is_adhoc = kind == "adhoc";
+    let body = if is_adhoc {
+        "Take notes?".to_string()
     } else {
-        format!("in {} min", (starts_in_secs / 60).max(1))
+        format_time_range_subtitle(
+            scheduled_start.as_deref(),
+            scheduled_end.as_deref(),
+            starts_in_secs,
+        )
     };
-    let body = format!("Starts {}", pretty_in);
     dlog!(
-        "[clips-tray] notify_meeting_starting id={} title={} body={}",
+        "[clips-tray] notify_meeting_starting type={} id={} title={} body={}",
+        kind,
         meeting_id,
         title,
         body
@@ -136,15 +180,23 @@ pub async fn notify_meeting_starting(
     // Keep the latest payload available for cold overlay windows, then emit
     // for already-mounted listeners.
     let payload = serde_json::json!({
-        "type": "calendar",
+        "type": kind,
         "title": title,
         "subtitle": body,
         "meetingId": meeting_id,
         "joinUrl": join_url,
+        "platform": platform,
+        "scheduledStart": scheduled_start,
+        "scheduledEnd": scheduled_end,
         "autoStart": auto_start.unwrap_or(false),
     });
     store_pending_meeting_notification(&app, &payload);
     let _ = app.emit("meetings:show-notification", payload.clone());
 
+    // Ensure the overlay window exists / is visible for cold starts.
+    if let Err(err) = show_meeting_notification_window(&app) {
+        eprintln!("[clips-tray] show meeting notification failed: {err}");
+    }
+
     Ok(())
 }

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

@@ -10,8 +10,8 @@ use crate::clips::{remember_voice_target, toggle_popover};
 use crate::dlog;
 use crate::state::{DictationActive, VoiceWakePopover};
 use crate::util::{
-    hide_voice_wake_popover, is_dictation_active, is_recording_active, set_dictation_active,
-    show_without_activation,
+    hide_voice_wake_popover, is_dictation_active, is_meeting_active, is_recording_active,
+    set_dictation_active, show_without_activation,
 };
 
 fn escape_shortcut() -> Shortcut {
@@ -513,7 +513,7 @@ pub fn build_shortcut_plugin() -> tauri_plugin_global_shortcut::Builder<tauri::W
             // global shortcut stops it rather than re-opening the
             // popover. Keeps parity with the tray-icon click
             // behaviour in `on_tray_icon_event`.
-            if is_recording_active(app) {
+            if is_recording_active(app) && !is_meeting_active(app) {
                 let _ = app.emit("clips:recorder-stop", ());
             } else {
                 toggle_popover(app);

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

@@ -341,7 +341,7 @@ fn install_call_ended_watcher(app: &AppHandle, threshold_ms: u64) {
                     fired = false;
                     continue;
                 }
-                let front = frontmost_bundle_id();
+                let front = crate::util::frontmost_bundle_id();
                 let is_strong_vc = front
                     .as_ref()
                     .map(|b| strong_vc_bundles.iter().any(|k| k == b))
@@ -408,27 +408,3 @@ fn audio_recently_silent(state: &tauri::State<'_, DetectorState>, threshold_ms:
         .unwrap_or(false);
     mic_silent && system_silent
 }
-
-#[cfg(target_os = "macos")]
-fn frontmost_bundle_id() -> Option<String> {
-    // Lightweight shell-out to avoid extra crates: AppleScript via `osascript`
-    // returns the bundle id of the frontmost app. This avoids pulling in a
-    // full objc2 dependency just for one read.
-    use std::process::Command;
-    let out = Command::new("osascript")
-        .args([
-            "-e",
-            "tell application \"System Events\" to get bundle identifier of (first process whose frontmost is true)",
-        ])
-        .output()
-        .ok()?;
-    if !out.status.success() {
-        return None;
-    }
-    let s = String::from_utf8(out.stdout).ok()?.trim().to_string();
-    if s.is_empty() {
-        None
-    } else {
-        Some(s)
-    }
-}

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

@@ -34,6 +34,11 @@ pub struct RecordingActive(pub Mutex<bool>);
 #[derive(Default)]
 pub struct MeetingActive(pub Mutex<bool>);
 
+/// Active meeting id, when meeting notes are currently running. Kept separate
+/// from `MeetingActive` so older boolean-only state checks stay simple.
+#[derive(Default)]
+pub struct ActiveMeetingId(pub Mutex<Option<String>>);
+
 #[allow(dead_code)]
 /// Whether dictation is toggled on.
 #[derive(Default)]

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

@@ -8,7 +8,7 @@ use crate::clips::{force_show_popover, toggle_popover};
 use crate::dlog;
 use crate::state::{TrayAnchor, TrayMeetings};
 use crate::tray_meetings::{build_meetings_section, handle_meeting_menu_click, MeetingItem};
-use crate::util::is_recording_active;
+use crate::util::{is_meeting_active, is_recording_active};
 use crate::TRAY_PNG;
 
 /// Build the full tray menu with the given upcoming-meetings list. Used both
@@ -22,15 +22,18 @@ fn build_menu_with_meetings(
     let meetings_submenu = build_meetings_section(app, meetings)?;
     let show_item = MenuItem::with_id(app, "show", "Show popover", true, None::<&str>)?;
     let recording_active = is_recording_active(app);
+    let meeting_active = is_meeting_active(app);
     let stop_item = MenuItem::with_id(
         app,
         "stop",
-        if recording_active {
+        if meeting_active {
+            "Stop meeting notes"
+        } else if recording_active {
             "Stop recording"
         } else {
             "No active recording"
         },
-        recording_active,
+        recording_active || meeting_active,
         None::<&str>,
     )?;
     let has_last_dictation = app
@@ -132,7 +135,11 @@ pub fn build_tray(app: &tauri::App) -> Result<(), Box<dyn std::error::Error>> {
             match id_ref {
                 "show" => force_show_popover(app),
                 "stop" => {
-                    let _ = app.emit("clips:recorder-stop", ());
+                    if is_meeting_active(app) {
+                        let _ = app.emit("clips:pill-stop", serde_json::json!({}));
+                    } else {
+                        let _ = app.emit("clips:recorder-stop", ());
+                    }
                 }
                 "paste-last-dictation" => {
                     let app = app.clone();
@@ -213,8 +220,13 @@ pub fn build_tray(app: &tauri::App) -> Result<(), Box<dyn std::error::Error>> {
             {
                 let app = tray.app_handle();
                 let active = is_recording_active(app);
-                dlog!("[clips-tray] tray click — is_recording_active={}", active);
-                if active {
+                let meeting_active = is_meeting_active(app);
+                dlog!(
+                    "[clips-tray] tray click — is_recording_active={} is_meeting_active={}",
+                    active,
+                    meeting_active
+                );
+                if active && !meeting_active {
                     let _ = app.emit("clips:recorder-stop", ());
                 } else {
                     toggle_popover(app);

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

@@ -5,7 +5,7 @@ use crate::state::{
     DictationActive, PopoverShownAt, RecordingActive, TrayAnchor, VoiceWakePopover,
 };
 
-const POPOVER_SHADOW_GUTTER_LOGICAL: f64 = 12.0;
+const POPOVER_SHADOW_GUTTER_LOGICAL: f64 = 24.0;
 const POPOVER_DEFAULT_WIDTH_LOGICAL: f64 = 360.0;
 const POPOVER_DEFAULT_HEIGHT_LOGICAL: f64 = 520.0;
 
@@ -425,6 +425,41 @@ pub fn is_recording_active(app: &AppHandle) -> bool {
         .unwrap_or(false)
 }
 
+pub fn is_meeting_active(app: &AppHandle) -> bool {
+    use crate::state::MeetingActive;
+    app.try_state::<MeetingActive>()
+        .and_then(|s| s.0.lock().ok().map(|g| *g))
+        .unwrap_or(false)
+}
+
+/// Bundle id of the frontmost macOS app, or `None` on failure / non-macOS.
+/// Uses a lightweight `osascript` shell-out so callers don't need objc2.
+#[cfg(target_os = "macos")]
+pub fn frontmost_bundle_id() -> Option<String> {
+    use std::process::Command;
+    let out = Command::new("osascript")
+        .args([
+            "-e",
+            "tell application \"System Events\" to get bundle identifier of (first process whose frontmost is true)",
+        ])
+        .output()
+        .ok()?;
+    if !out.status.success() {
+        return None;
+    }
+    let s = String::from_utf8(out.stdout).ok()?.trim().to_string();
+    if s.is_empty() {
+        None
+    } else {
+        Some(s)
+    }
+}
+
+#[cfg(not(target_os = "macos"))]
+pub fn frontmost_bundle_id() -> Option<String> {
+    None
+}
+
 pub fn set_dictation_active(app: &AppHandle, active: bool) {
     if let Some(state) = app.try_state::<DictationActive>() {
         if let Ok(mut g) = state.0.lock() {

package/corpus/templates/clips/package.json

@@ -71,7 +71,6 @@
     "@types/node": "^24.2.1",
     "@types/react": "catalog:",
     "@types/react-dom": "catalog:",
-    "@typescript/native-preview": "catalog:",
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/addon-web-links": "^0.12.0",
     "@xterm/xterm": "^6.0.0",
@@ -93,7 +92,8 @@
     "tailwind-merge": "^3.5.0",
     "tailwindcss": "catalog:",
     "tsx": "^4.20.3",
-    "typescript": "^6.0.3",
+    "typescript": "catalog:",
+    "typescript-7": "catalog:",
     "vaul": "^1.1.2",
     "vite": "catalog:",
     "vitest": "catalog:"

package/corpus/templates/content/.agents/skills/self-modifying-code/SKILL.md

@@ -28,7 +28,19 @@ Not all modifications are equal. Use this to decide what level of care is needed
 | 1: Data       | Files in `data/`      | JSON state, generated content, markdown          | Nothing — these are routine       |
 | 2: Source     | App code              | Components, routes, styles, scripts              | Run `pnpm typecheck && pnpm lint` |
 | 3: Config     | Project config        | `package.json`, `tsconfig.json`, `vite.config.*` | Ask for explicit approval first   |
-| 4: Off limits | Secrets and framework | `.env`, `@agent-native/core` internals           | Never modify these                |
+| 4: Off limits | Secrets and framework | `.env`, `@agent-native/*` packages & overrides   | Never modify these                |
+
+Tier 4 includes **all** of the following — not only editing package source:
+
+- Files under `node_modules/@agent-native/*` (core, dispatch, scheduling, …)
+- `pnpm.overrides`, `overrides`, `resolutions`, or `patchedDependencies` that
+  target any `@agent-native/*` package
+- Local patches, vendored copies, or invented "dispatch/core behavior"
+  shims meant to paper over a version skew or failed upgrade
+
+When an older branch needs current packages, use **`agent-native upgrade`**
+(see the `upgrade-agent-native` skill). If upgrade or typecheck fails, fix
+**app** code or stop and ask — do not patch the framework.
 
 ## Git Checkpoint Pattern
 
@@ -74,13 +86,19 @@ inline strings in components.
 ## Don't
 
 - Don't modify `.env` files or files containing secrets
-- Don't modify `@agent-native/core` package internals
+- Don't modify `@agent-native/core`, `@agent-native/dispatch`, or other
+  `@agent-native/*` package internals (including under `node_modules`)
+- Don't add `pnpm.overrides` / `patchedDependencies` / `resolutions` for
+  `@agent-native/*` to "make the app run" after a version bump
+- Don't invent local dispatch/core behavior overrides when upgrade fails —
+  run `npx @agent-native/core@latest upgrade`, then fix app-level errors only
 - Don't modify `.agents/skills/` or `AGENTS.md` unless explicitly requested
 - Don't skip the typecheck/lint step after editing source code
 - Don't make source changes without a git checkpoint to roll back to
 
 ## Related Skills
 
+- **upgrade-agent-native** — supported path to bring an older app/workspace current
 - **storing-data** — Tier 1 modifications (data files) are the safest and most common
 - **actions** — The agent can create or modify actions to add new capabilities
 - **delegate-to-agent** — Self-modification requests come through the agent chat

package/corpus/templates/content/.agents/skills/upgrade-agent-native/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: upgrade-agent-native
+description: >-
+  Bring an older Agent Native app or workspace current. Use when updating
+  @agent-native/core, fixing a broken upgrade, or when tempted to patch or
+  override core/dispatch packages to make an old branch run.
+scope: dev
+metadata:
+  internal: true
+---
+
+# Upgrade Agent Native
+
+## Rule
+
+When an older Agent Native app/branch needs to run on current packages, use
+`agent-native upgrade`. Never "fix" upgrade breakage with
+`pnpm.overrides`, `patchedDependencies`, `resolutions`, local patches, or
+edits under `node_modules/@agent-native/*` — especially not against
+`@agent-native/core` or `@agent-native/dispatch`.
+
+## Why
+
+Agents often respond to a failed core bump by inventing framework patches and
+dispatch behavior overrides. That hides the real app-level break, drifts from
+upstream, and makes the next upgrade worse. The supported path is bump →
+install → refresh scaffold skills → verify, then fix **app** code only.
+
+## How
+
+1. **Doctor first (optional but recommended)**
+
+   ```bash
+   npx @agent-native/core@latest upgrade check
+   ```
+
+   This reports framework overrides/patches and pending `@agent-native/*`
+   bumps. If overrides/patches are present, remove them before continuing.
+
+2. **Run the upgrade**
+
+   ```bash
+   npx @agent-native/core@latest upgrade
+   ```
+
+   Or from an already-installed CLI: `pnpm exec agent-native upgrade` /
+   `agent-native upgrade`.
+
+   What it does:
+
+   - Blocks (unless `--force`) when `@agent-native/*` overrides/patches exist
+   - Rewrites non-local `@agent-native/*` dependency pins to `latest`
+   - Runs the package manager install
+   - Runs `skills update scaffold --project`
+   - Runs `typecheck` when the project has that script
+
+3. **If upgrade or typecheck fails**
+
+   - Read the concrete error
+   - Fix **app** source, actions, config, or env — not framework packages
+   - Re-run `agent-native upgrade` or `pnpm typecheck`
+   - Stop and ask the user if you cannot fix the app-level error
+
+4. **Dry-run / partial runs**
+
+   ```bash
+   agent-native upgrade --dry-run
+   agent-native upgrade --skip-verify
+   agent-native upgrade --skip-install   # package.json bumps only
+   ```
+
+## Don't
+
+- Don't add `pnpm.overrides`, `overrides`, `resolutions`, or
+  `patchedDependencies` for any `@agent-native/*` package
+- Don't edit `node_modules/@agent-native/core` or
+  `node_modules/@agent-native/dispatch`
+- Don't invent local "dispatch behavior" shims to paper over version skew
+- Don't keep iterating with more framework patches after a failed install
+- Don't skip `skills update scaffold --project` after a core bump (the
+  upgrade command does this for you)
+
+## Related Skills
+
+- **self-modifying-code** — Tier 4: framework packages are off limits
+- **agent-native-docs** — version-matched docs after the bump
+- **portability** — keep app code provider-agnostic across upgrades

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

@@ -0,0 +1,8 @@
+export function chunks<T>(items: T[], size: number): T[][] {
+  if (items.length === 0) return [];
+  const out: T[][] = [];
+  for (let index = 0; index < items.length; index += size) {
+    out.push(items.slice(index, index + size));
+  }
+  return out;
+}

package/corpus/templates/content/actions/_builder-cms-read-client.ts

@@ -59,8 +59,9 @@ const BUILDER_CMS_DEFAULT_READ_LIMIT = 500;
 const BUILDER_CMS_MAX_READ_LIMIT = 1000;
 const BUILDER_CMS_PAGE_SIZE = 100;
 const BUILDER_CMS_READ_RETRIES = 2;
-const BUILDER_CMS_ENTRY_FIELDS =
-  "id,name,published,lastUpdated,createdDate,data.title,data.handle,data.url,data.slug,data.date,data.description,data.status,data.author,data.image,data.blocks,data.blocksString";
+const BUILDER_CMS_METADATA_ENTRY_FIELDS =
+  "id,name,published,lastUpdated,createdDate,data.title,data.handle,data.url,data.slug,data.date,data.description,data.status,data.author,data.image";
+const BUILDER_CMS_BODY_ENTRY_FIELDS = `${BUILDER_CMS_METADATA_ENTRY_FIELDS},data.blocks,data.blocksString`;
 
 function builderContentApiHost() {
   return (
@@ -489,7 +490,7 @@ async function readBuilderCmsContentEntriesViaMcp(args: {
             modelName: args.model,
             limit: pageLimit,
             offset,
-            fields: BUILDER_CMS_ENTRY_FIELDS,
+            fields: BUILDER_CMS_METADATA_ENTRY_FIELDS,
             enrich: true,
           },
         },
@@ -599,7 +600,7 @@ async function readBuilderCmsContentEntriesViaMcp(args: {
             modelName: args.model,
             limit: 1,
             query: { id: entry.id },
-            fields: BUILDER_CMS_ENTRY_FIELDS,
+            fields: BUILDER_CMS_METADATA_ENTRY_FIELDS,
             enrich: true,
           },
         },
@@ -649,6 +650,7 @@ async function readBuilderCmsContentEntriesViaContentApi(args: {
   // bare reference id.
   url.searchParams.set("enrich", "true");
   url.searchParams.set("noCache", "true");
+  url.searchParams.set("fields", BUILDER_CMS_METADATA_ENTRY_FIELDS);
 
   const limit = readLimit(args.limit);
   const startOffset =
@@ -814,7 +816,7 @@ export async function readBuilderCmsContentEntry(args: {
   url.searchParams.set("enrich", "true");
   url.searchParams.set("noCache", "true");
   url.searchParams.set("cachebust", String(Date.now()));
-  url.searchParams.set("fields", BUILDER_CMS_ENTRY_FIELDS);
+  url.searchParams.set("fields", BUILDER_CMS_BODY_ENTRY_FIELDS);
 
   const response = await fetchBuilderContentPage({
     fetchImpl: args.fetchImpl ?? fetch,

package/corpus/templates/content/actions/_content-database-personal-view.ts

@@ -0,0 +1,80 @@
+import { getUserSetting } from "@agent-native/core/settings";
+import { assertAccess } from "@agent-native/core/sharing";
+import { and, eq, isNull } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+
+export const PERSONAL_DATABASE_VIEW_OVERRIDES_VERSION = 1;
+
+export const personalDatabaseViewSettingKey = (databaseId: string) =>
+  `content-database-personal-view:${databaseId}`;
+
+export const sortSchema = z.object({
+  key: z.string(),
+  label: z.string(),
+  direction: z.enum(["asc", "desc"]),
+});
+
+export const filterSchema = z.object({
+  key: z.string(),
+  label: z.string(),
+  operator: z.enum([
+    "contains",
+    "equals",
+    "does_not_equal",
+    "greater_than",
+    "less_than",
+    "before",
+    "after",
+    "between",
+    "is_checked",
+    "is_unchecked",
+    "is_empty",
+    "is_not_empty",
+  ]),
+  value: z.string(),
+  filterGroupId: z.string().optional(),
+  parentFilterGroupId: z.string().optional(),
+});
+
+export const personalViewOverridesSchema = z.object({
+  version: z.literal(PERSONAL_DATABASE_VIEW_OVERRIDES_VERSION),
+  activeViewId: z.string().optional(),
+  views: z.array(
+    z.object({
+      id: z.string(),
+      sorts: z.array(sortSchema).default([]),
+      filters: z.array(filterSchema).default([]),
+      filterMode: z.enum(["and", "or"]).default("and"),
+    }),
+  ),
+});
+
+export async function assertContentDatabaseViewerAccess(databaseId: string) {
+  const db = getDb();
+  const [database] = await db
+    .select()
+    .from(schema.contentDatabases)
+    .where(
+      and(
+        eq(schema.contentDatabases.id, databaseId),
+        isNull(schema.contentDatabases.deletedAt),
+      ),
+    );
+  if (!database) throw new Error(`Database "${databaseId}" not found`);
+
+  await assertAccess("document", database.documentId, "viewer");
+}
+
+export async function readPersonalDatabaseViewOverrides(
+  userEmail: string,
+  databaseId: string,
+) {
+  const stored = await getUserSetting(
+    userEmail,
+    personalDatabaseViewSettingKey(databaseId),
+  );
+  const parsed = personalViewOverridesSchema.safeParse(stored);
+  return parsed.success ? parsed.data : null;
+}