@agent-native/core 0.172.1 → 0.172.3

package/corpus/templates/clips/desktop/src/components/ReadinessPanel.tsx

@@ -116,6 +116,9 @@ export function ReadinessPanel({
 
   const [statuses, setStatuses] = useState<PermissionStatuses | null>(null);
   const [checking, setChecking] = useState(false);
+  const [refreshingPane, setRefreshingPane] = useState<MacosPrivacyPane | null>(
+    null,
+  );
 
   const checkStatuses = useCallback(async () => {
     setChecking(true);
@@ -126,6 +129,18 @@ export function ReadinessPanel({
     }
   }, []);
 
+  const refreshPermissions = useCallback(
+    (pane: MacosPrivacyPane) => {
+      setRefreshingPane(null);
+      window.requestAnimationFrame(() => setRefreshingPane(pane));
+      window.setTimeout(() => {
+        setRefreshingPane((current) => (current === pane ? null : current));
+      }, 450);
+      void checkStatuses();
+    },
+    [checkStatuses],
+  );
+
   const grantPermission = useCallback(
     (pane: MacosPrivacyPane) =>
       requestOrOpenPermission(pane, {
@@ -172,8 +187,8 @@ export function ReadinessPanel({
                     {mac ? (
                       <button
                         type="button"
-                        className={`readiness-refresh ${checking ? "readiness-refresh-spinning" : ""}`}
-                        onClick={checkStatuses}
+                        className={`readiness-refresh ${refreshingPane === item.pane ? "readiness-refresh-rotating" : ""}`}
+                        onClick={() => refreshPermissions(item.pane)}
                         disabled={checking}
                         aria-label="Recheck permissions"
                         title="Recheck"

package/corpus/templates/clips/desktop/src/hooks/useMeetingTranscription.ts

@@ -306,8 +306,27 @@ export function useMeetingTranscription({
           capturedUntil: string;
         } | null;
       } = { current: null };
+      let includeFromMeetingStart = payload.includeFromMeetingStart === true;
       try {
-        if (payload.includeFromMeetingStart) {
+        if (
+          !includeFromMeetingStart &&
+          payload.reason === "user" &&
+          payload.scheduledStart
+        ) {
+          try {
+            const historyStatus = await invoke<{ available: boolean }>(
+              "rewind_meeting_history_status",
+              { scheduledStart: payload.scheduledStart },
+            );
+            includeFromMeetingStart = historyStatus.available === true;
+          } catch (error) {
+            console.warn(
+              "[clips-popover] Rewind meeting history status unavailable:",
+              error,
+            );
+          }
+        }
+        if (includeFromMeetingStart) {
           if (payload.reason !== "user" || !payload.scheduledStart) {
             throw new Error(
               "Include from meeting start is only available when you manually start a scheduled meeting.",
@@ -614,7 +633,7 @@ export function useMeetingTranscription({
         // The local index may need a moment after the fragment fence. Anchor
         // the live engine where it actually begins, not at the earlier click,
         // so every stored segment remains on one honest meeting timeline.
-        if (payload.includeFromMeetingStart && payload.scheduledStart) {
+        if (includeFromMeetingStart && payload.scheduledStart) {
           session.liveTimelineOffsetMs = Math.max(
             0,
             Date.now() - Date.parse(payload.scheduledStart),

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

@@ -350,6 +350,7 @@ export function MeetingNotification() {
       meetingId: data.meetingId,
       joinUrl: data.joinUrl,
       reason: "user",
+      scheduledStart: data.scheduledStart,
     }).catch((err) => {
       setPending(false);
       setError((err as Error)?.message ?? "Could not start notes.");

package/corpus/templates/clips/desktop/src/styles.css

@@ -1131,9 +1131,17 @@ body[data-clips-route="recording-pill"] #root {
   cursor: pointer;
   border-radius: var(--radius-sm);
   transition:
+    opacity 120ms,
     color 120ms,
     background 120ms;
   flex-shrink: 0;
+  opacity: 0;
+}
+
+.readiness-item:hover .readiness-refresh,
+.readiness-item:focus-within .readiness-refresh,
+.readiness-item .readiness-refresh-rotating {
+  opacity: 1;
 }
 
 .readiness-refresh:hover {
@@ -1146,8 +1154,8 @@ body[data-clips-route="recording-pill"] #root {
   cursor: default;
 }
 
-.readiness-refresh-spinning svg {
-  animation: readiness-spin 0.8s linear infinite;
+.readiness-refresh-rotating svg {
+  animation: readiness-spin 420ms ease-out;
 }
 
 @keyframes readiness-spin {
@@ -1156,6 +1164,12 @@ body[data-clips-route="recording-pill"] #root {
   }
 }
 
+@media (prefers-reduced-motion: reduce) {
+  .readiness-refresh-rotating svg {
+    animation: none;
+  }
+}
+
 .readiness-empty {
   padding: 8px;
   color: var(--fg-muted);
@@ -1620,7 +1634,7 @@ body[data-clips-route="recording-pill"] #root {
   flex-direction: column;
   gap: 6px;
   margin-bottom: 4px;
-  max-height: 280px;
+  max-height: 420px;
   overflow-y: auto;
   overflow-x: hidden;
   overscroll-behavior: contain;

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

@@ -17,13 +17,16 @@ use tauri::{AppHandle, Emitter, Manager};
 
 use crate::config::{feature_config, MeetingTranscriptionMode};
 use crate::dlog;
-use crate::meetings_watcher::MeetingsWatcherState;
+use crate::meetings_watcher::{
+    find_matching_calendar_meeting, parse_meetings, MeetingItem, MeetingsWatcherState,
+    CALENDAR_MATCH_WINDOW_MINUTES,
+};
 
 /// How often to sample the frontmost app.
-const POLL_SECS: u64 = 4;
+const POLL_SECS: u64 = 2;
 
 /// Require this many consecutive frontmost seconds before firing.
-const DWELL_SECS: u64 = 9;
+const DWELL_SECS: u64 = 3;
 
 /// After dismiss / fire, suppress re-prompts for this platform until the
 /// cooldown elapses (or the VC app leaves front — see tick logic).
@@ -202,7 +205,7 @@ async fn tick_macos(
     let front = crate::util::frontmost_bundle_id();
     let matched = front.as_deref().and_then(match_vc_bundle);
 
-    let Some((platform, title)) = matched else {
+    let Some((platform, fallback_title)) = matched else {
         // VC app left front — clear session dedupe so a later re-focus can
         // fire again (cooldown still applies).
         clear_session_if_left(app, None);
@@ -294,8 +297,8 @@ async fn tick_macos(
         platform
     );
 
-    let meeting_id = match create_adhoc_meeting(app, client, platform).await {
-        Ok(id) => id,
+    let meeting = match create_adhoc_meeting(app, client, platform).await {
+        Ok(meeting) => meeting,
         Err(err) => {
             // Allow retry on next dwell if create failed.
             if let Some(state) = app.try_state::<AdhocMeetingsWatcherState>() {
@@ -315,22 +318,34 @@ async fn tick_macos(
 
     if show_widget {
         let app_clone = app.clone();
-        let id_clone = meeting_id.clone();
-        let title_clone = title.to_string();
-        let platform_clone = platform.to_string();
-        let scheduled_start = chrono::Utc::now().to_rfc3339();
+        let id_clone = meeting.id.clone();
+        let title_clone = meeting
+            .title
+            .clone()
+            .unwrap_or_else(|| fallback_title.to_string());
+        let platform_clone = meeting
+            .platform
+            .clone()
+            .unwrap_or_else(|| platform.to_string());
+        let scheduled_start = meeting
+            .scheduled_start
+            .clone()
+            .or_else(|| Some(chrono::Utc::now().to_rfc3339()));
+        let scheduled_end = meeting.scheduled_end.clone();
+        let join_url = meeting.join_url.clone();
+        let source = meeting.source.clone().or_else(|| Some("adhoc".to_string()));
         tauri::async_runtime::spawn(async move {
             let _ = crate::notifications::notify_meeting_starting(
                 app_clone,
                 id_clone,
                 title_clone,
                 0,
-                None,
-                Some(scheduled_start),
-                None,
+                join_url,
+                scheduled_start,
+                scheduled_end,
                 Some(platform_clone),
                 Some(auto_start),
-                Some("adhoc".to_string()),
+                source,
             )
             .await;
         });
@@ -340,9 +355,10 @@ async fn tick_macos(
         let _ = app.emit(
             "meetings:start-transcription",
             serde_json::json!({
-                "meetingId": meeting_id,
-                "joinUrl": null,
+                "meetingId": meeting.id,
+                "joinUrl": meeting.join_url,
                 "reason": "adhoc-auto",
+                "scheduledStart": meeting.scheduled_start,
             }),
         );
     }
@@ -472,26 +488,49 @@ async fn create_adhoc_meeting(
     app: &AppHandle,
     client: &reqwest::Client,
     platform: &str,
-) -> Result<String, String> {
+) -> Result<MeetingItem, String> {
     let session = app
         .try_state::<MeetingsWatcherState>()
         .map(|s| s.session_snapshot())
         .unwrap_or_default();
-    let Some(server_url) = session.server_url else {
+    let Some(server_url) = session.server_url.as_deref() else {
         return Err("no server_url for create-meeting".to_string());
     };
 
+    // The native watcher knows which conferencing app is active, but not the
+    // calendar event title. Resolve the nearest joinable event first so a
+    // calendar-backed meeting keeps its title, URL, and scheduled span. A
+    // disconnected calendar only loses that enrichment and still gets an
+    // adhoc meeting below.
+    match find_calendar_meeting(app, client, server_url, &session, platform).await {
+        Ok(Some(meeting)) => {
+            dlog!(
+                "[clips-tray] adhoc matched calendar meeting {} for {}",
+                meeting.id,
+                platform
+            );
+            return Ok(meeting);
+        }
+        Ok(None) => {}
+        Err(error) => dlog!(
+            "[clips-tray] adhoc calendar title lookup skipped for {}: {}",
+            platform,
+            error
+        ),
+    }
+
     let url = format!("{}/_agent-native/actions/create-meeting", server_url);
     let row_title = if platform == "zoom" {
         "Zoom meeting"
     } else {
         "Teams meeting"
     };
+    let scheduled_start = chrono::Utc::now().to_rfc3339();
     let body = serde_json::json!({
         "title": row_title,
         "platform": platform,
         "source": "adhoc",
-        "scheduledStart": chrono::Utc::now().to_rfc3339(),
+        "scheduledStart": scheduled_start,
     });
 
     let mut req = client
@@ -524,14 +563,69 @@ async fn create_adhoc_meeting(
         ));
     }
     let body: serde_json::Value = resp.json().await.map_err(|e| e.to_string())?;
-    extract_meeting_id(&body).ok_or_else(|| {
+    let id = extract_meeting_id(&body).ok_or_else(|| {
         format!(
             "create-meeting response missing meeting id: {}",
             body.to_string().chars().take(200).collect::<String>()
         )
+    })?;
+    Ok(MeetingItem {
+        id,
+        title: Some(row_title.to_string()),
+        scheduled_start: Some(scheduled_start),
+        scheduled_end: None,
+        join_url: None,
+        platform: Some(platform.to_string()),
+        source: Some("adhoc".to_string()),
     })
 }
 
+async fn find_calendar_meeting(
+    app: &AppHandle,
+    client: &reqwest::Client,
+    server_url: &str,
+    session: &crate::meetings_watcher::MeetingsSessionSnapshot,
+    platform: &str,
+) -> Result<Option<MeetingItem>, String> {
+    let url = format!("{server_url}/_agent-native/actions/list-meetings");
+    let upcoming_within_min = CALENDAR_MATCH_WINDOW_MINUTES.to_string();
+    let mut req = client.get(url).query(&[
+        ("view", "upcoming"),
+        ("limit", "20"),
+        ("upcomingWithinMin", upcoming_within_min.as_str()),
+        ("includeStartedWithinMin", "15"),
+        ("excludePersonalSoloEvents", "true"),
+        ("excludeDeclinedEvents", "true"),
+    ]);
+    req = req.header("X-Request-Source", "clips-desktop");
+    if let Some(cookie) = session.session_cookie.as_deref() {
+        req = req.header("Cookie", cookie);
+    }
+    if let Some(token) = session.auth_token.as_deref() {
+        req = req.bearer_auth(token);
+    }
+    let response = req
+        .send()
+        .await
+        .map_err(|error| format!("list-meetings fetch: {error}"))?;
+    if response.status() == reqwest::StatusCode::UNAUTHORIZED {
+        let _ = app.emit("meetings:auth-needed", serde_json::json!({}));
+        return Err("list-meetings http 401".to_string());
+    }
+    if !response.status().is_success() {
+        return Err(format!("list-meetings http {}", response.status()));
+    }
+    let body: serde_json::Value = response
+        .json()
+        .await
+        .map_err(|error| format!("list-meetings response: {error}"))?;
+    Ok(find_matching_calendar_meeting(
+        &parse_meetings(&body),
+        platform,
+        chrono::Utc::now(),
+    ))
+}
+
 fn extract_meeting_id(body: &serde_json::Value) -> Option<String> {
     // Framework wraps action returns as `{ result: { meeting, created } }`.
     let meeting = body

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

@@ -1,6 +1,6 @@
 //! Background poller for upcoming meetings.
 //!
-//! Runs as a tokio task spawned from `lib.rs::run` setup. Every 30s it calls
+//! Runs as a tokio task spawned from `lib.rs::run` setup. Every 10s it calls
 //! the backend's `list-meetings` action for the next handful of live Google
 //! Calendar meetings. For any meeting in the Granola-style reminder window
 //! (1 minute before start through 5 minutes after) that we haven't already
@@ -134,21 +134,24 @@ impl MeetingsWatcherState {
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
-struct MeetingItem {
-    id: String,
-    title: Option<String>,
+pub(crate) struct MeetingItem {
+    pub(crate) id: String,
+    pub(crate) title: Option<String>,
     #[serde(default, alias = "scheduledStart")]
-    scheduled_start: Option<String>,
+    pub(crate) scheduled_start: Option<String>,
     #[serde(default, alias = "scheduledEnd")]
-    scheduled_end: Option<String>,
+    pub(crate) scheduled_end: Option<String>,
     #[serde(default, alias = "joinUrl")]
-    join_url: Option<String>,
+    pub(crate) join_url: Option<String>,
     #[serde(default)]
-    platform: Option<String>,
+    pub(crate) platform: Option<String>,
     #[serde(default)]
-    source: Option<String>,
+    pub(crate) source: Option<String>,
 }
 
+pub(crate) const CALENDAR_MATCH_WINDOW_MINUTES: i64 = 15;
+const CALENDAR_MATCH_AMBIGUITY_MARGIN_SECS: i64 = 60;
+
 #[derive(Debug, Deserialize)]
 struct ListMeetingsResponse {
     #[serde(default)]
@@ -245,7 +248,7 @@ pub fn spawn_watcher(app: AppHandle) {
 }
 
 async fn run_watcher(app: AppHandle) {
-    let mut interval = tokio::time::interval(Duration::from_secs(30));
+    let mut interval = tokio::time::interval(Duration::from_secs(10));
     // Skip the first tick — gives the frontend time to push us a server URL.
     interval.tick().await;
     let client = match reqwest::Client::builder()
@@ -316,7 +319,7 @@ async fn tick_once(app: &AppHandle, client: &reqwest::Client) -> Result<(), Stri
     let status = resp.status();
     if status == reqwest::StatusCode::UNAUTHORIZED {
         // Tell the renderer to re-push a fresh cookie or surface a
-        // re-login prompt. We keep silently retrying every 30s — once
+        // re-login prompt. We keep silently retrying every 10s - once
         // the renderer pushes a new cookie via
         // `meetings_watcher_set_session` we'll succeed on the next tick.
         let _ = app.emit("meetings:auth-needed", serde_json::json!({}));
@@ -454,8 +457,47 @@ fn is_calendar_reminder_candidate(meeting: &MeetingItem) -> bool {
     meeting.source.as_deref() != Some("adhoc")
 }
 
-fn parse_meetings(body: &serde_json::Value) -> Vec<MeetingItem> {
-    if let Ok(parsed) = serde_json::from_value::<ListMeetingsResponse>(body.clone()) {
+pub(crate) fn find_matching_calendar_meeting(
+    meetings: &[MeetingItem],
+    platform: &str,
+    started_at: chrono::DateTime<chrono::Utc>,
+) -> Option<MeetingItem> {
+    let mut candidates: Vec<_> = meetings
+        .iter()
+        .filter_map(|meeting| {
+            if !is_calendar_reminder_candidate(meeting)
+                || meeting
+                    .platform
+                    .as_deref()
+                    .is_none_or(|value| !value.eq_ignore_ascii_case(platform))
+                || meeting.join_url.as_deref().is_none_or(str::is_empty)
+            {
+                return None;
+            }
+            let scheduled_start = meeting
+                .scheduled_start
+                .as_deref()
+                .and_then(|value| chrono::DateTime::parse_from_rfc3339(value).ok())?
+                .with_timezone(&chrono::Utc);
+            let distance = (scheduled_start - started_at).num_seconds().abs();
+            (distance <= CALENDAR_MATCH_WINDOW_MINUTES * 60).then(|| (distance, meeting))
+        })
+        .collect();
+    candidates.sort_by_key(|(distance, _)| *distance);
+    let Some((distance, meeting)) = candidates.first() else {
+        return None;
+    };
+    if candidates.get(1).is_some_and(|(next_distance, _)| {
+        next_distance - distance <= CALENDAR_MATCH_AMBIGUITY_MARGIN_SECS
+    }) {
+        return None;
+    }
+    Some((*meeting).clone())
+}
+
+pub(crate) fn parse_meetings(body: &serde_json::Value) -> Vec<MeetingItem> {
+    let payload = body.get("result").unwrap_or(body);
+    if let Ok(parsed) = serde_json::from_value::<ListMeetingsResponse>(payload.clone()) {
         if let Some(v) = parsed.upcoming {
             return v;
         }
@@ -466,7 +508,7 @@ fn parse_meetings(body: &serde_json::Value) -> Vec<MeetingItem> {
             return v;
         }
     }
-    if let Ok(arr) = serde_json::from_value::<Vec<MeetingItem>>(body.clone()) {
+    if let Ok(arr) = serde_json::from_value::<Vec<MeetingItem>>(payload.clone()) {
         return arr;
     }
     Vec::new()
@@ -474,7 +516,9 @@ fn parse_meetings(body: &serde_json::Value) -> Vec<MeetingItem> {
 
 #[cfg(test)]
 mod tests {
-    use super::{is_calendar_reminder_candidate, parse_meetings};
+    use chrono::{TimeZone, Utc};
+
+    use super::{find_matching_calendar_meeting, is_calendar_reminder_candidate, parse_meetings};
 
     #[test]
     fn excludes_adhoc_meetings_from_calendar_reminders() {
@@ -512,4 +556,75 @@ mod tests {
         assert_eq!(meetings.len(), 1);
         assert!(is_calendar_reminder_candidate(&meetings[0]));
     }
+
+    #[test]
+    fn finds_the_nearest_joinable_calendar_meeting_for_adhoc_detection() {
+        let meetings = parse_meetings(&serde_json::json!({
+            "result": {
+                "meetings": [
+                    {
+                        "id": "too-far",
+                        "title": "Later Zoom",
+                        "scheduledStart": "2026-07-22T19:40:00Z",
+                        "joinUrl": "https://zoom.us/j/2",
+                        "platform": "zoom",
+                        "source": "calendar"
+                    },
+                    {
+                        "id": "nearest",
+                        "title": "Product sync",
+                        "scheduledStart": "2026-07-22T19:11:00Z",
+                        "joinUrl": "https://zoom.us/j/1",
+                        "platform": "zoom",
+                        "source": "calendar"
+                    },
+                    {
+                        "id": "adhoc",
+                        "title": "Zoom meeting",
+                        "scheduledStart": "2026-07-22T19:10:00Z",
+                        "joinUrl": "https://zoom.us/j/3",
+                        "platform": "zoom",
+                        "source": "adhoc"
+                    }
+                ]
+            }
+        }));
+
+        let started_at = Utc.with_ymd_and_hms(2026, 7, 22, 19, 10, 0).unwrap();
+        let matched = find_matching_calendar_meeting(&meetings, "zoom", started_at);
+
+        assert_eq!(
+            matched.as_ref().map(|meeting| meeting.id.as_str()),
+            Some("nearest")
+        );
+        assert_eq!(
+            matched.and_then(|meeting| meeting.title),
+            Some("Product sync".to_string())
+        );
+    }
+
+    #[test]
+    fn avoids_ambiguous_same_platform_calendar_matches() {
+        let meetings = parse_meetings(&serde_json::json!({
+            "meetings": [
+                {
+                    "id": "first",
+                    "scheduledStart": "2026-07-22T19:09:00Z",
+                    "joinUrl": "https://zoom.us/j/1",
+                    "platform": "zoom",
+                    "source": "calendar"
+                },
+                {
+                    "id": "second",
+                    "scheduledStart": "2026-07-22T19:11:00Z",
+                    "joinUrl": "https://zoom.us/j/2",
+                    "platform": "zoom",
+                    "source": "calendar"
+                }
+            ]
+        }));
+
+        let started_at = Utc.with_ymd_and_hms(2026, 7, 22, 19, 10, 0).unwrap();
+        assert!(find_matching_calendar_meeting(&meetings, "zoom", started_at).is_none());
+    }
 }

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

@@ -44,9 +44,8 @@ mod macos {
 
     extern "C" {
         fn CGPreflightScreenCaptureAccess() -> bool;
-        // kIOHIDRequestTypeListenEvent = 1; returns IOHIDAccessType where
-        // kIOHIDAccessTypeGranted = 0, kIOHIDAccessTypeDenied = 1, kIOHIDAccessTypeUnknown = 2
-        fn IOHIDCheckAccess(request_type: u32) -> i32;
+        // This is the preflight for the CGEventTap used by the Fn listener.
+        fn CGPreflightListenEventAccess() -> bool;
     }
 
     pub fn check_all() -> PermissionStatuses {
@@ -85,6 +84,6 @@ mod macos {
     }
 
     fn check_input_monitoring() -> bool {
-        unsafe { IOHIDCheckAccess(1) == 0 }
+        unsafe { CGPreflightListenEventAccess() }
     }
 }

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

@@ -870,6 +870,26 @@ async function withMutationLocks<T>(
   );
 }
 
+export function nextPosition(max: unknown): number {
+  const raw = max ?? -1;
+  const value =
+    typeof raw === "number"
+      ? raw
+      : typeof raw === "string" && raw.trim() !== ""
+        ? Number(raw)
+        : Number.NaN;
+  const next = value + 1;
+  if (
+    !Number.isSafeInteger(value) ||
+    value < -1 ||
+    !Number.isSafeInteger(next) ||
+    next > 2_147_483_647
+  ) {
+    throw new Error("Database position is outside the supported range.");
+  }
+  return next;
+}
+
 async function createInsideTransaction(
   tx: Db,
   context: MutationContext,
@@ -913,7 +933,7 @@ async function createInsideTransaction(
     title: args.title?.trim() ?? "",
     content: "",
     icon: null,
-    position: (maxDoc?.max ?? -1) + 1,
+    position: nextPosition(maxDoc?.max),
     isFavorite: 0,
     hideFromSearch: context.databaseDocument.hideFromSearch ?? 0,
     visibility: context.databaseDocument.visibility ?? "private",
@@ -926,7 +946,7 @@ async function createInsideTransaction(
     orgId: context.database.orgId,
     databaseId: context.database.id,
     documentId,
-    position: (maxItem?.max ?? -1) + 1,
+    position: nextPosition(maxItem?.max),
     createdAt: now,
     updatedAt: now,
   });

package/dist/agent/production-agent.js

@@ -4431,6 +4431,12 @@ export async function runAgentLoop(opts) {
                         completedSideEffect: false,
                     });
                     recordToolResult(result, false);
+                    // Control is genuinely handed to the user here — the result above
+                    // tells the model "the turn is paused". `requestedActionStop` alone
+                    // does not stop anything until after the tool loop drains, so
+                    // without this the *rest* of this assistant message still executes
+                    // while the human is still looking at the approval card.
+                    turnYieldedToUser = true;
                     requestedActionStop ??= {
                         message: `Waiting for your approval to run ${toolCall.name}.`,
                         errorCode: "needs-approval",
@@ -5029,6 +5035,16 @@ export async function runAgentLoop(opts) {
             // call and break the model's intended sequencing.
             if (!entry)
                 return null;
+            // A call that can pause the turn must not share a batch. `flushParallelBatch`
+            // dispatches through `Promise.all`, so a gated call and its siblings all
+            // start before the gate is reached, and `turnYieldedToUser` would then be
+            // set too late to stop a sibling that already ran. Serializing here is what
+            // makes that flag mean anything for the calls after it. `needsApproval` may
+            // be an async predicate, so this cannot resolve whether approval is truly
+            // required — declaring it at all is enough to serialize.
+            if (entry.needsApproval !== undefined || entry.endsTurn === true) {
+                return null;
+            }
             if (entry.readOnly === true)
                 return "read";
             if (entry.parallelSafe === true)
@@ -5056,7 +5072,8 @@ export async function runAgentLoop(opts) {
         // as not executed rather than running them: a second `ask-question` would
         // overwrite the first one's card before anyone could answer it.
         const skipToolCallAfterYield = (toolCall) => {
-            const result = `Not executed: ${toolCall.name} was called after an action that ends the turn. ` +
+            const result = `Not executed: ${toolCall.name} was called after an action that paused the turn ` +
+                `(an action that ends the turn, or one waiting on the user's approval). ` +
                 `The turn is paused for the user's answer — call it again on a later turn if still needed.`;
             send({
                 type: "tool_start",

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;