@agent-native/core 0.94.0 → 0.94.2

package/corpus/core/src/client/composer/useRealtimeVoiceMode.tsx

@@ -10,6 +10,7 @@ import {
 } from "react";
 import { createPortal } from "react-dom";
 
+import { requestAgentChatThreadOpen } from "../agent-chat.js";
 import {
   SIDEBAR_STATE_CHANGE_EVENT,
   type AgentSidebarStateChangeDetail,
@@ -18,6 +19,13 @@ import { agentNativePath } from "../api-path.js";
 import { readClientAppState, setClientAppState } from "../application-state.js";
 import { getBrowserTabId } from "../browser-tab-id.js";
 import { useT } from "../i18n.js";
+import {
+  createRealtimeVoiceAudioLevelStore,
+  normalizeRealtimeVoiceRms,
+  smoothRealtimeVoiceLevel,
+  type RealtimeVoiceAudioLevelStore,
+} from "./realtime-voice-audio-level.js";
+import { realtimeVoiceTranscriptRegistry } from "./realtime-voice-transcript.js";
 import {
   RealtimeVoiceModeDock,
   type RealtimeVoiceModeCopy,
@@ -43,11 +51,54 @@ export interface RealtimeVoiceModeApi {
   active: boolean;
   errorMessage: string | null;
   chatVisible: boolean;
+  audioLevels: RealtimeVoiceAudioLevelStore;
   start: () => Promise<void>;
   end: () => void;
   toggleChat: () => void;
 }
 
+export interface CompletedRealtimeVoiceTranscript {
+  role: "user" | "assistant";
+  text: string;
+  providerId?: string;
+}
+
+/**
+ * Voice mode owns the chat only temporarily. Restore the captured transcript
+ * when it is still the user's active thread (or the chat has no active thread)
+ * but never pull them back after they deliberately selected another thread.
+ */
+export function shouldRestoreRealtimeVoiceTranscriptThread(
+  transcriptThreadId: string | undefined,
+  activeThreadId: string | undefined,
+): transcriptThreadId is string {
+  return Boolean(
+    transcriptThreadId &&
+    (!activeThreadId || activeThreadId === transcriptThreadId),
+  );
+}
+
+export function extractCompletedRealtimeVoiceTranscript(
+  event: RealtimeServerEvent,
+): CompletedRealtimeVoiceTranscript | null {
+  const userCompleted =
+    event.type === "conversation.item.input_audio_transcription.completed";
+  const assistantCompleted =
+    event.type === "response.output_audio_transcript.done";
+  if (!userCompleted && !assistantCompleted) return null;
+  const text =
+    typeof event.transcript === "string" ? event.transcript.trim() : "";
+  if (!text) return null;
+  const providerId = [event.item_id, event.response_id, event.event_id].find(
+    (value): value is string => typeof value === "string" && value.length > 0,
+  );
+  return {
+    role: userCompleted ? "user" : "assistant",
+    text,
+    ...(providerId ? { providerId } : {}),
+  };
+}
+
 export interface RealtimeVoiceModeProviderProps {
   children: ReactNode;
   browserTabId?: string;
@@ -232,17 +283,29 @@ function useRealtimeVoiceModeController(
   const [state, setState] = useState<"idle" | RealtimeVoiceModeState>("idle");
   const [error, setError] = useState<string | null>(null);
   const [chatVisible, setChatVisible] = useState(false);
+  const [audioLevels] = useState(createRealtimeVoiceAudioLevelStore);
   const stateRef = useRef(state);
   const peerRef = useRef<RTCPeerConnection | null>(null);
   const channelRef = useRef<RTCDataChannel | null>(null);
   const streamRef = useRef<MediaStream | null>(null);
   const audioRef = useRef<HTMLAudioElement | null>(null);
+  const audioContextRef = useRef<AudioContext | null>(null);
+  const inputAnalyserRef = useRef<AnalyserNode | null>(null);
+  const outputAnalyserRef = useRef<AnalyserNode | null>(null);
+  const inputMeterBufferRef = useRef<Uint8Array<ArrayBuffer> | null>(null);
+  const outputMeterBufferRef = useRef<Uint8Array<ArrayBuffer> | null>(null);
+  const inputSourceRef = useRef<MediaStreamAudioSourceNode | null>(null);
+  const outputSourceRef = useRef<MediaStreamAudioSourceNode | null>(null);
+  const meterFrameRef = useRef<number | null>(null);
+  const lastMeterSampleRef = useRef(0);
   const abortRef = useRef<AbortController | null>(null);
   const handledCallsRef = useRef(new Set<string>());
   const sessionIdRef = useRef<string | undefined>(undefined);
   const startedAtRef = useRef<string | undefined>(undefined);
   const lastUserTextRef = useRef("");
   const lastAssistantTextRef = useRef("");
+  const transcriptThreadIdRef = useRef<string | undefined>(undefined);
+  const transcriptSequenceRef = useRef(0);
 
   useEffect(() => {
     stateRef.current = state;
@@ -279,6 +342,77 @@ function useRealtimeVoiceModeController(
     [syncAppState],
   );
 
+  const startMeterLoop = useCallback(() => {
+    if (meterFrameRef.current !== null) return;
+    const sample = (timestamp: number) => {
+      meterFrameRef.current = requestAnimationFrame(sample);
+      if (timestamp - lastMeterSampleRef.current < 50) return;
+      lastMeterSampleRef.current = timestamp;
+
+      const current = audioLevels.getSnapshot();
+      let input = current.input;
+      let output = current.output;
+      const inputAnalyser = inputAnalyserRef.current;
+      const inputBuffer = inputMeterBufferRef.current;
+      if (inputAnalyser && inputBuffer) {
+        inputAnalyser.getByteTimeDomainData(inputBuffer);
+        input = smoothRealtimeVoiceLevel(
+          input,
+          normalizeRealtimeVoiceRms(inputBuffer),
+        );
+      }
+      const outputAnalyser = outputAnalyserRef.current;
+      const outputBuffer = outputMeterBufferRef.current;
+      if (outputAnalyser && outputBuffer) {
+        outputAnalyser.getByteTimeDomainData(outputBuffer);
+        output = smoothRealtimeVoiceLevel(
+          output,
+          normalizeRealtimeVoiceRms(outputBuffer),
+        );
+      }
+      audioLevels.set({ input, output });
+    };
+    meterFrameRef.current = requestAnimationFrame(sample);
+  }, [audioLevels]);
+
+  const attachAudioMeter = useCallback(
+    (stream: MediaStream, channel: "input" | "output") => {
+      try {
+        const AudioCtor =
+          window.AudioContext ??
+          (
+            window as typeof window & {
+              webkitAudioContext?: typeof AudioContext;
+            }
+          ).webkitAudioContext;
+        if (!AudioCtor) return;
+        const context = audioContextRef.current ?? new AudioCtor();
+        audioContextRef.current = context;
+        void context.resume().catch(() => undefined);
+        const analyser = context.createAnalyser();
+        analyser.fftSize = 512;
+        const source = context.createMediaStreamSource(stream);
+        source.connect(analyser);
+        const buffer = new Uint8Array(analyser.frequencyBinCount);
+        if (channel === "input") {
+          inputSourceRef.current?.disconnect();
+          inputSourceRef.current = source;
+          inputAnalyserRef.current = analyser;
+          inputMeterBufferRef.current = buffer;
+        } else {
+          outputSourceRef.current?.disconnect();
+          outputSourceRef.current = source;
+          outputAnalyserRef.current = analyser;
+          outputMeterBufferRef.current = buffer;
+        }
+        startMeterLoop();
+      } catch {
+        // Audio metering is visual-only; keep the realtime call healthy.
+      }
+    },
+    [startMeterLoop],
+  );
+
   const cleanupTransport = useCallback(() => {
     abortRef.current?.abort();
     abortRef.current = null;
@@ -293,8 +427,25 @@ function useRealtimeVoiceModeController(
       audioRef.current.srcObject = null;
     }
     audioRef.current = null;
+    if (meterFrameRef.current !== null) {
+      cancelAnimationFrame(meterFrameRef.current);
+      meterFrameRef.current = null;
+    }
+    inputSourceRef.current?.disconnect();
+    outputSourceRef.current?.disconnect();
+    inputSourceRef.current = null;
+    outputSourceRef.current = null;
+    inputAnalyserRef.current = null;
+    outputAnalyserRef.current = null;
+    inputMeterBufferRef.current = null;
+    outputMeterBufferRef.current = null;
+    lastMeterSampleRef.current = 0;
+    const audioContext = audioContextRef.current;
+    audioContextRef.current = null;
+    if (audioContext) void audioContext.close().catch(() => undefined);
+    audioLevels.reset();
     handledCallsRef.current.clear();
-  }, []);
+  }, [audioLevels]);
 
   const fail = useCallback(
     (message: string, options?: { openKeySettings?: boolean }) => {
@@ -342,6 +493,26 @@ function useRealtimeVoiceModeController(
     [browserTabId, transition],
   );
 
+  const persistCompletedTranscript = useCallback(
+    (event: RealtimeServerEvent) => {
+      const transcript = extractCompletedRealtimeVoiceTranscript(event);
+      const threadId = transcriptThreadIdRef.current;
+      if (!transcript || !threadId) return;
+      const sessionIdentity =
+        sessionIdRef.current ?? startedAtRef.current ?? "pending";
+      const providerIdentity =
+        transcript.providerId ?? `sequence-${++transcriptSequenceRef.current}`;
+      realtimeVoiceTranscriptRegistry.publish({
+        id: `realtime-voice:${sessionIdentity}:${transcript.role}:${providerIdentity}`,
+        threadId,
+        role: transcript.role,
+        text: transcript.text,
+        createdAt: new Date().toISOString(),
+      });
+    },
+    [],
+  );
+
   const handleServerEvent = useCallback(
     (event: RealtimeServerEvent) => {
       if (event.type === "session.created") {
@@ -367,14 +538,16 @@ function useRealtimeVoiceModeController(
         if (typeof event.transcript === "string") {
           lastAssistantTextRef.current = event.transcript;
         }
+        persistCompletedTranscript(event);
         syncAppState("speaking");
       } else if (
         event.type === "conversation.item.input_audio_transcription.completed"
       ) {
         if (typeof event.transcript === "string") {
           lastUserTextRef.current = event.transcript;
-          syncAppState("working");
         }
+        persistCompletedTranscript(event);
+        syncAppState("working");
       } else if (event.type === "response.done") {
         const response = event.response;
         const status =
@@ -410,7 +583,14 @@ function useRealtimeVoiceModeController(
         transition("listening");
       }
     },
-    [copy, fail, handleFunctionCall, syncAppState, transition],
+    [
+      copy,
+      fail,
+      handleFunctionCall,
+      persistCompletedTranscript,
+      syncAppState,
+      transition,
+    ],
   );
 
   const start = useCallback(async () => {
@@ -430,6 +610,9 @@ function useRealtimeVoiceModeController(
     lastUserTextRef.current = "";
     lastAssistantTextRef.current = "";
     sessionIdRef.current = undefined;
+    transcriptThreadIdRef.current =
+      realtimeVoiceTranscriptRegistry.activeThreadId();
+    transcriptSequenceRef.current = 0;
     transition("connecting");
     setChatVisible(false);
     window.dispatchEvent(new Event("agent-panel:close"));
@@ -445,6 +628,7 @@ function useRealtimeVoiceModeController(
         },
       });
       streamRef.current = stream;
+      attachAudioMeter(stream, "input");
 
       const peer = new RTCPeerConnection();
       peerRef.current = peer;
@@ -455,7 +639,9 @@ function useRealtimeVoiceModeController(
       audio.setAttribute("playsinline", "");
       audioRef.current = audio;
       peer.ontrack = (trackEvent) => {
-        audio.srcObject = trackEvent.streams[0] ?? null;
+        const remoteStream = trackEvent.streams[0] ?? null;
+        audio.srcObject = remoteStream;
+        if (remoteStream) attachAudioMeter(remoteStream, "output");
         void audio.play().catch(() => undefined);
       };
 
@@ -501,15 +687,42 @@ function useRealtimeVoiceModeController(
       const status = (startError as { status?: unknown })?.status;
       fail(errorMessage(startError), { openKeySettings: status === 400 });
     }
-  }, [browserTabId, copy, fail, handleServerEvent, transition]);
+  }, [
+    attachAudioMeter,
+    browserTabId,
+    copy,
+    fail,
+    handleServerEvent,
+    transition,
+  ]);
 
   const end = useCallback(() => {
     if (stateRef.current === "idle" || stateRef.current === "ending") return;
+    const transcriptThreadId = transcriptThreadIdRef.current;
+    const activeThreadId = realtimeVoiceTranscriptRegistry.activeThreadId();
     transition("ending");
     cleanupTransport();
     setError(null);
     sessionIdRef.current = undefined;
     startedAtRef.current = undefined;
+    transcriptThreadIdRef.current = undefined;
+    setChatVisible(true);
+    if (
+      shouldRestoreRealtimeVoiceTranscriptThread(
+        transcriptThreadId,
+        activeThreadId,
+      )
+    ) {
+      requestAgentChatThreadOpen({
+        threadId: transcriptThreadId,
+        // The request is delivered asynchronously. Re-checking this at the
+        // receiver prevents a navigation that happened during that gap from
+        // being overwritten.
+        onlyIfActiveThreadId: transcriptThreadId,
+      });
+    } else {
+      window.dispatchEvent(new Event("agent-panel:open"));
+    }
     transition("idle");
   }, [cleanupTransport, transition]);
 
@@ -538,6 +751,7 @@ function useRealtimeVoiceModeController(
     active: state !== "idle",
     errorMessage: error,
     chatVisible,
+    audioLevels,
     start,
     end,
     toggleChat,
@@ -568,10 +782,10 @@ export function RealtimeVoiceModeProvider({
               state={voice.state === "idle" ? "ending" : voice.state}
               copy={copy}
               chatVisible={voice.chatVisible}
+              audioLevels={voice.audioLevels}
               onToggleChat={voice.toggleChat}
               onEndVoiceMode={voice.end}
               errorMessage={voice.errorMessage}
-              className="z-[270]"
             />,
             document.body,
           )

package/corpus/core/src/client/use-chat-threads.ts

@@ -939,15 +939,39 @@ export function useChatThreads(
           titleSource,
           { preserveUserTitle },
         );
-        await fetch(`${apiUrl}/threads/${encodeURIComponent(id)}`, {
-          method: "PUT",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            ...threadDataPayload,
-            title,
-            scope: localScope,
-          }),
-        });
+        const payload = {
+          ...threadDataPayload,
+          title,
+          scope: localScope,
+        };
+        let response = await fetch(
+          `${apiUrl}/threads/${encodeURIComponent(id)}`,
+          {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+          },
+        );
+        // A passive realtime-voice transcript can be the first content in a
+        // client-created thread, so no agent run has created its SQL row yet.
+        // Materialize that row idempotently and retry the same full save.
+        if (response.status === 404) {
+          const created = await fetch(`${apiUrl}/threads`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ id, title, scope: localScope }),
+          });
+          if (!created.ok) return;
+          response = await fetch(
+            `${apiUrl}/threads/${encodeURIComponent(id)}`,
+            {
+              method: "PUT",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify(payload),
+            },
+          );
+        }
+        if (!response.ok) return;
         emitThreadsUpdated();
         // Update local thread list metadata. If the thread isn't in our
         // local list yet (an optimistic-only thread that the server just

package/corpus/core/src/templates/workspace-core/.agents/skills/voice-transcription/SKILL.md

@@ -46,8 +46,11 @@ from the dictation providers below. It requires the authenticated user's
 configuration, and keeps the key out of browser code.
 
 - Starting voice mode collapses the chat into a persistent bottom-end speech
-  orb. Clicking the orb shows or hides chat without ending the session; ending
-  the session is a separate, explicit control.
+  orb. The orb stays visible above the chat even when the chat opens
+  automatically. Clicking it shows or hides chat without ending the session;
+  ending the session is a separate, explicit control.
+- The orb's compact waveform must reflect actual microphone or assistant audio
+  activity. It is an audio-level indicator, not a decorative animation.
 - Semantic VAD keeps listening, starts responses automatically, and supports
   barge-in while the agent is speaking.
 - Function calls must cross the authenticated realtime tool bridge and enter
@@ -57,9 +60,12 @@ configuration, and keeps the key out of browser code.
 - Preserve the active browser-tab id in request context so `set-url`,
   `set-search-params`, `view-screen`, and tab-scoped application state affect
   the app the user is actually speaking to.
-- Do not persist audio. Store only compact lifecycle and latest-transcript
-  context at `application_state["realtime-voice-session"]`; delete it when the
-  session ends.
+- Do not persist audio or interim transcript deltas. Append completed user and
+  assistant utterances as ordinary text messages to the exact chat thread
+  captured when the session starts. Ending voice mode opens that chat so the
+  user can continue over text. Store only compact lifecycle and latest context
+  at `application_state["realtime-voice-session"]`; delete it when the session
+  ends.
 - Missing-key failures should open Settings focused on the user-scoped
   `OPENAI_API_KEY` field. Never send, log, or echo the key to the browser.
 

package/corpus/templates/clips/app/components/player/comments-panel.tsx

@@ -717,6 +717,8 @@ function CommentCard({
     return updatedReactions;
   }
 
+  const commentContent = linkifyCommentContent(comment.content);
+
   return (
     <div className={cn("flex gap-2", comment.resolved && "opacity-60")}>
       <Avatar className="h-7 w-7 shrink-0">
@@ -747,7 +749,7 @@ function CommentCard({
           ) : null}
         </div>
         <p className="text-sm text-foreground whitespace-pre-wrap break-words mt-0.5">
-          {comment.content}
+          {commentContent}
         </p>
 
         <div className="flex items-center gap-2 mt-1.5 text-xs text-muted-foreground">
@@ -856,6 +858,101 @@ function CommentCard({
   );
 }
 
+const COMMENT_URL_PATTERN = /\b(?:https?:\/\/|www\.)[^\s<]+/gi;
+const ALWAYS_TRAILING_PUNCTUATION = new Set([
+  ".",
+  ",",
+  "!",
+  "?",
+  ";",
+  ":",
+  "'",
+  '"',
+]);
+const PAIRED_TRAILING_PUNCTUATION: Record<string, string> = {
+  ")": "(",
+  "]": "[",
+  "}": "{",
+};
+
+function trimTrailingUrlPunctuation(value: string): {
+  url: string;
+  trailing: string;
+} {
+  let end = value.length;
+
+  while (end > 0) {
+    const lastCharacter = value[end - 1];
+    if (ALWAYS_TRAILING_PUNCTUATION.has(lastCharacter)) {
+      end -= 1;
+      continue;
+    }
+
+    const openingCharacter = PAIRED_TRAILING_PUNCTUATION[lastCharacter];
+    if (openingCharacter) {
+      const candidate = value.slice(0, end);
+      const openingCount = candidate.split(openingCharacter).length - 1;
+      const closingCount = candidate.split(lastCharacter).length - 1;
+      if (closingCount > openingCount) {
+        end -= 1;
+        continue;
+      }
+    }
+
+    break;
+  }
+
+  return {
+    url: value.slice(0, end),
+    trailing: value.slice(end),
+  };
+}
+
+function linkifyCommentContent(content: string): React.ReactNode[] {
+  const result: React.ReactNode[] = [];
+  let lastIndex = 0;
+
+  for (const match of content.matchAll(COMMENT_URL_PATTERN)) {
+    const matchIndex = match.index;
+    const matchedText = match[0];
+    const { url, trailing } = trimTrailingUrlPunctuation(matchedText);
+    const href = url.toLowerCase().startsWith("www.") ? `https://${url}` : url;
+
+    let isValidUrl = false;
+    try {
+      isValidUrl = Boolean(new URL(href).hostname);
+    } catch {
+      // Leave malformed URL-like text unlinked.
+    }
+
+    if (!isValidUrl) continue;
+
+    if (matchIndex > lastIndex) {
+      result.push(content.slice(lastIndex, matchIndex));
+    }
+    result.push(
+      <a
+        key={`${matchIndex}-${url}`}
+        href={href}
+        target="_blank"
+        rel="noopener noreferrer"
+        className="text-primary hover:underline"
+      >
+        {url}
+      </a>,
+    );
+    if (trailing) result.push(trailing);
+
+    lastIndex = matchIndex + matchedText.length;
+  }
+
+  if (lastIndex < content.length) {
+    result.push(content.slice(lastIndex));
+  }
+
+  return result;
+}
+
 function parseReactions(raw: string): Record<string, string[]> {
   try {
     const v = JSON.parse(raw ?? "{}");

package/corpus/templates/clips/changelog/2026-07-10-comment-urls-open-as-clickable-links.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-10
+---
+
+Comment URLs open as clickable links.

package/corpus/templates/clips/changelog/2026-07-10-desktop-recording-uploads-now-show-a-brief-uploaded-state-wi.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Desktop recording uploads now show a brief Uploaded state with open and dismiss controls instead of staying stuck onscreen.

package/corpus/templates/clips/changelog/2026-07-10-desktop-recordings-now-retry-saving-their-locally-captured-t.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Desktop recordings now retry saving their locally captured transcript after upload completes.

package/corpus/templates/clips/changelog/2026-07-10-desktop-update-prompts-are-more-compact-and-easier-to-dismiss.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-10
+---
+
+Clips desktop update prompts are now more compact and easier to dismiss.

package/corpus/templates/clips/changelog/2026-07-10-quiet-recordings-now-finish-saving-instead-of-getting-stuck.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Quiet or interrupted recordings now finish saving, and locally saved clips retry correctly.

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

@@ -1,3 +1,4 @@
+import { IconX } from "@tabler/icons-react";
 import { useState } from "react";
 
 import {
@@ -73,7 +74,7 @@ export function UpdateBanner() {
       <div className="update-banner update-banner--pending">
         <DownloadIcon />
         <span className="update-banner-text">
-          Update {status.version} available — downloading…
+          Update available — downloading…
         </span>
       </div>
     );
@@ -94,15 +95,17 @@ export function UpdateBanner() {
   return (
     <div className="update-banner update-banner--ready">
       <span className="update-banner-text">
-        Update {status.version} ready — restart to install.
+        Update ready — restart to install
       </span>
       <div className="update-banner-actions">
         <button
           type="button"
-          className="update-banner-btn update-banner-btn--ghost"
+          className="update-banner-btn update-banner-btn--dismiss"
           onClick={() => setDismissedVersion(status.version)}
+          aria-label="Dismiss update"
+          title="Dismiss update"
         >
-          Later
+          <IconX size={15} strokeWidth={1.8} aria-hidden />
         </button>
         <button
           type="button"