@agent-native/core 0.114.6 → 0.114.8

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

@@ -157,6 +157,26 @@ export function ReadinessPanel({
     }
   }, []);
 
+  const requestOrOpenPermission = useCallback(
+    async (pane: MacosPrivacyPane) => {
+      if (mac && pane === "screen") {
+        try {
+          const granted = await invoke<boolean>(
+            "system_audio_request_permission",
+          );
+          await checkStatuses();
+          if (granted) return;
+        } catch {
+          // Fall through to the dedicated privacy pane. The request API may
+          // be unavailable on an older macOS build or the user may already
+          // have denied the prompt once.
+        }
+      }
+      onOpenPermission(pane);
+    },
+    [checkStatuses, mac, onOpenPermission],
+  );
+
   useEffect(() => {
     if (open && !statuses && mac) checkStatuses();
   }, [open, statuses, mac, checkStatuses]);
@@ -219,7 +239,7 @@ export function ReadinessPanel({
                       <button
                         type="button"
                         className="readiness-open-button"
-                        onClick={() => onOpenPermission(item.pane)}
+                        onClick={() => void requestOrOpenPermission(item.pane)}
                       >
                         Open
                       </button>

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

@@ -2,10 +2,12 @@ export function Switch({
   on,
   onChange,
   label,
+  disabled = false,
 }: {
   on: boolean;
   onChange: (v: boolean) => void;
   label: string;
+  disabled?: boolean;
 }) {
   return (
     <button
@@ -14,6 +16,7 @@ export function Switch({
       role="switch"
       aria-checked={on}
       aria-label={label}
+      disabled={disabled}
       onClick={() => onChange(!on)}
     >
       <span className="switch-thumb" aria-hidden />

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

@@ -23,6 +23,8 @@ export interface MeetingTranscriptionPayload {
   meetingId: string;
   joinUrl?: string | null;
   reason?: "user" | "calendar-auto" | string;
+  scheduledStart?: string | null;
+  includeFromMeetingStart?: boolean;
 }
 
 interface MeetingTranscriptionSession {
@@ -35,6 +37,9 @@ interface MeetingTranscriptionSession {
   stopping: boolean;
   paused: boolean;
   engine: TranscriptionEngine;
+  /** Offset local live-engine timestamps onto the scheduled meeting timeline. */
+  liveTimelineOffsetMs: number;
+  historyInFlight: Promise<void> | null;
   // Single-flight flush bookkeeping (M3): `flushInFlight` is the promise of
   // the currently-running save-browser-transcript call (or null). `flushSeq`
   // is bumped every time flushTranscript is invoked; `dirtySeq` records the
@@ -175,6 +180,9 @@ export function useMeetingTranscription({
           }
         });
         await invoke("silence_detector_stop").catch(() => {});
+        if (reason !== "app-quit") {
+          await session.historyInFlight?.catch(() => {});
+        }
         // Final flush waits for any in-flight flush first (flushTranscript's
         // single-flight coalescing) then sends the definitive snapshot.
         await flushTranscript().catch((err) => {
@@ -257,7 +265,29 @@ export function useMeetingTranscription({
         await stopTranscription("replaced");
       }
 
+      let historyPreparedRef: {
+        current: {
+          token: string;
+          scheduledStart: string;
+          capturedUntil: string;
+        } | null;
+      } = { current: null };
       try {
+        if (payload.includeFromMeetingStart) {
+          if (payload.reason !== "user" || !payload.scheduledStart) {
+            throw new Error(
+              "Include from meeting start is only available when you manually start a scheduled meeting.",
+            );
+          }
+          historyPreparedRef.current = await invoke<{
+            token: string;
+            scheduledStart: string;
+            capturedUntil: string;
+          }>("rewind_meeting_history_prepare", {
+            scheduledStart: payload.scheduledStart,
+          });
+        }
+
         const result = await callClipsAction<{
           meetingId?: string;
           scheduledEnd?: string | null;
@@ -286,19 +316,13 @@ export function useMeetingTranscription({
           stopping: false,
           paused: false,
           engine: "whisper",
+          liveTimelineOffsetMs: 0,
+          historyInFlight: null,
           flushInFlight: null,
           flushSeq: 0,
           dirtySeq: 0,
         };
         sessionRef.current = session;
-        await invoke("set_recording_state", { active: true }).catch(() => {});
-        await invoke("set_meeting_active", {
-          active: true,
-          meetingId: resolvedMeetingId,
-        }).catch(() => {});
-        emit("meetings:transcription-started", {
-          meetingId: resolvedMeetingId,
-        }).catch(() => {});
 
         const scheduleFlush = () => {
           if (session.flushTimer) window.clearTimeout(session.flushTimer);
@@ -325,7 +349,23 @@ export function useMeetingTranscription({
         addUnlisten(
           onFinalTranscript((event) => {
             if (sessionRef.current !== session) return;
-            if (appendFinalTranscript(event, session.lines, session.segments)) {
+            const timelineEvent = session.liveTimelineOffsetMs
+              ? {
+                  ...event,
+                  segments: event.segments.map((segment) => ({
+                    ...segment,
+                    startMs: segment.startMs + session.liveTimelineOffsetMs,
+                    endMs: segment.endMs + session.liveTimelineOffsetMs,
+                  })),
+                }
+              : event;
+            if (
+              appendFinalTranscript(
+                timelineEvent,
+                session.lines,
+                session.segments,
+              )
+            ) {
               scheduleFlush();
             }
           }),
@@ -471,24 +511,15 @@ export function useMeetingTranscription({
           }),
         );
 
-        // Pill init — set synchronously before the pill mounts so pill-ready
-        // re-emit has meetingId available immediately.
+        // Prepare the pill payload before live audio starts, but don't show a
+        // recording indicator or publish an active meeting until the engine
+        // has actually acquired its audio source. This keeps "Recording"
+        // truthful when model/capture startup fails.
         pendingPillInitRef.current = {
           meetingId: resolvedMeetingId,
           initialNotes: "",
         };
 
-        await invoke("recording_pill_show", {
-          meetingId: resolvedMeetingId,
-          mode: "meeting",
-        });
-
-        // Immediate emit covers the reused-window case (pill already mounted).
-        emit("clips:pill-context", {
-          meetingId: resolvedMeetingId,
-          mode: "meeting",
-        }).catch(() => {});
-
         callClipsAction<{
           meeting?: { userNotesMd?: string };
           transcript?: { segmentsJson?: string | null } | null;
@@ -503,6 +534,11 @@ export function useMeetingTranscription({
             pendingPillInitRef.current = {
               meetingId: resolvedMeetingId,
               initialNotes,
+              preloadedLines: session.segments.map((segment) => ({
+                text: segment.text,
+                source: segment.source,
+                startMs: segment.startMs,
+              })),
             };
             emit("clips:meeting-notes-init", {
               meetingId: resolvedMeetingId,
@@ -534,9 +570,9 @@ export function useMeetingTranscription({
                     ...preloadedSegments,
                     ...session.segments,
                   ];
-                  const preloadedLines = segs.map((s) => ({
+                  const preloadedLines = session.segments.map((s) => ({
                     text: s.text,
-                    source: (s.source ?? "mic") as "mic" | "system",
+                    source: s.source,
                     startMs: s.startMs,
                   }));
                   // Store in ref so clips:pill-ready can re-emit if the
@@ -560,6 +596,15 @@ export function useMeetingTranscription({
           })
           .catch(() => {});
 
+        // 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) {
+          session.liveTimelineOffsetMs = Math.max(
+            0,
+            Date.now() - Date.parse(payload.scheduledStart),
+          );
+        }
         session.engine = await startTranscriptionEngine({
           mic: { deviceId: selectedMicId, label: selectedMicLabel },
           // macOS 15+ uses ScreenCaptureKit's independent microphone output.
@@ -568,6 +613,81 @@ export function useMeetingTranscription({
           voiceProcessing: false,
         });
 
+        await invoke("set_recording_state", { active: true }).catch(() => {});
+        await invoke("set_meeting_active", {
+          active: true,
+          meetingId: resolvedMeetingId,
+        }).catch(() => {});
+        await invoke("recording_pill_show", {
+          meetingId: resolvedMeetingId,
+          mode: "meeting",
+        });
+        // Immediate emit covers the reused-window case (pill already mounted).
+        emit("clips:pill-context", {
+          meetingId: resolvedMeetingId,
+          mode: "meeting",
+        }).catch(() => {});
+        emit("meetings:transcription-started", {
+          meetingId: resolvedMeetingId,
+        }).catch(() => {});
+
+        // Indexing the fenced local fragment can take tens of seconds. It runs
+        // after live capture is active, then prepends its bounded rows into the
+        // same canonical session. A local-index failure is visible but never
+        // tears down notes that are already recording.
+        if (historyPreparedRef.current) {
+          const prepared = historyPreparedRef.current;
+          const historyPromise = invoke<{
+            segments: SourcedTranscriptSegment[];
+          }>("rewind_meeting_history_collect", { token: prepared.token })
+            .then((history) => {
+              if (sessionRef.current !== session) return;
+              const historyLines = history.segments.map(
+                (segment) => `${speakerFor(segment.source)}: ${segment.text}`,
+              );
+              session.lines = [...historyLines, ...session.lines];
+              session.segments = [...history.segments, ...session.segments];
+              const preloadedLines = session.segments.map((segment) => ({
+                text: segment.text,
+                source: segment.source,
+                startMs: segment.startMs,
+              }));
+              if (pendingPillInitRef.current?.meetingId === resolvedMeetingId) {
+                pendingPillInitRef.current = {
+                  ...pendingPillInitRef.current,
+                  preloadedLines,
+                };
+              }
+              emit("clips:transcript-preload", {
+                lines: preloadedLines,
+              }).catch(() => {});
+              flushTranscript().catch((err) => {
+                console.warn(
+                  "[clips-popover] earlier meeting transcript save failed:",
+                  err,
+                );
+              });
+            })
+            .catch((error) => {
+              const message =
+                typeof error === "string"
+                  ? error
+                  : error instanceof Error
+                    ? error.message
+                    : "Earlier local meeting audio could not be included.";
+              emit("meetings:history-error", {
+                meetingId: resolvedMeetingId,
+                error: message,
+              }).catch(() => {});
+            })
+            .finally(() => {
+              if (session.historyInFlight === historyPromise) {
+                session.historyInFlight = null;
+              }
+            });
+          session.historyInFlight = historyPromise;
+        }
+
         await invoke("silence_detector_start", {
           config: silenceDetectorConfig,
         }).catch(() => {});
@@ -580,7 +700,19 @@ export function useMeetingTranscription({
 
         emit("meetings:hide-notification", { meetingId }).catch(() => {});
       } catch (err) {
+        if (historyPreparedRef.current) {
+          invoke("rewind_meeting_history_cancel", {
+            token: historyPreparedRef.current.token,
+          }).catch(() => {});
+        }
+        const failedSession = sessionRef.current;
         sessionRef.current = null;
+        if (failedSession?.meetingId) {
+          await callClipsAction("stop-meeting-recording", {
+            meetingId: failedSession.meetingId,
+          }).catch(() => {});
+        }
+        pendingPillInitRef.current = null;
         await invoke("recording_pill_hide").catch(() => {});
         await invoke("set_recording_state", { active: false }).catch(() => {});
         await invoke("set_meeting_active", { active: false }).catch(() => {});

package/corpus/templates/clips/desktop/src/lib/native-recording-warm.ts

@@ -1,7 +1,8 @@
 /**
- * Hosted native start sequencing: overlap Whisper start, create-recording, and
- * deferred SCK warm so Skip no longer waits serially on Whisper then warm.
- * Begin/attach must still wait for this promise (transcription settled).
+ * Hosted native start sequencing: create the recording, warm its one physical
+ * SCK capture (which registers the shared audio producer), then attach Whisper
+ * as a PCM subscriber. The countdown still hides this work, while the ordering
+ * prevents a second microphone capture from muting both consumers.
  */
 export function planNativeFullscreenWarmOverlap<
   TRecording extends { id: string },
@@ -10,12 +11,10 @@ export function planNativeFullscreenWarmOverlap<
   startTranscription: () => Promise<unknown>;
   warmMic: (recordingId: string) => Promise<unknown>;
 }): Promise<TRecording> {
-  const transcriptionPromise = input.startTranscription();
   return (async () => {
     const created = await input.createRecording();
-    // Deferred-output warm may overlap remaining Whisper startup; frames are
-    // not written until begin attaches the recording output.
-    await Promise.all([transcriptionPromise, input.warmMic(created.id)]);
+    await input.warmMic(created.id);
+    await input.startTranscription();
     return created;
   })();
 }