@agent-native/core 0.114.9 → 0.114.11

package/corpus/templates/clips/app/components/player/video-player.tsx

@@ -277,9 +277,18 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
     // without this guard that effect would treat the two URLs as the "same
     // resource" and immediately revert our retry before `.load()` completes.
     const recoveringFromErrorRef = useRef(false);
+    const prevMseModeRef = useRef("");
+    // Render-phase mirrors of currentMs / isPlaying so the MSE-fallback effect
+    // below can read the pre-failure values. By the time effects run, React has
+    // already committed the new <video src>, causing the browser to reset
+    // currentTime -> 0 and paused -> true, making the element values useless.
+    const currentMsRef = useRef(startMs ?? 0);
+    const isPlayingRef = useRef(false);
     const [activeVideoSrc, setActiveVideoSrc] = useState(resolvedVideoSrc);
     const [isPlaying, setIsPlaying] = useState(false);
     const [currentMs, setCurrentMs] = useState(startMs ?? 0);
+    currentMsRef.current = currentMs;
+    isPlayingRef.current = isPlaying;
     const [loomStartMs, setLoomStartMs] = useState<number | null>(null);
     const [volume, setVolume] = useState(1);
     // Autoplaying players (e.g. the Slack unfurl embed, `?autoplay=1`) must
@@ -392,6 +401,45 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
         ? undefined
         : activeVideoSrc;
 
+    // When the MSE pipeline breaks mid-stream (premature 416 or
+    // ERR_CONTENT_LENGTH_MISMATCH after the backing GCS object is replaced by
+    // the compressed version), the loader calls onFatal which flips mse.mode to
+    // "native". This effect detects that transition and:
+    //  1. saves the playback position via currentMsRef (v.currentTime is already 0)
+    //  2. cache-busts activeVideoSrc so the native <video> path fetches fresh
+    //     headers rather than a proxy-cached content-length from the old object
+    //  3. if the user was playing, arms playAttemptPendingRef so the existing
+    //     retryPendingPlay call in onLoadedData resumes without user interaction
+    useEffect(() => {
+      const prev = prevMseModeRef.current;
+      prevMseModeRef.current = mse.mode;
+      if (prev !== "mse" || mse.mode !== "native") return;
+
+      const wasPlaying = isPlayingRef.current;
+      const posMs = currentMsRef.current > 0 ? currentMsRef.current : null;
+      if (posMs != null) resumeAfterReloadMsRef.current = posMs;
+
+      if (activeVideoSrc) {
+        recoveringFromErrorRef.current = true;
+        setActiveVideoSrc(
+          setUrlSearchParam(activeVideoSrc, "cb", String(Date.now())),
+        );
+      }
+
+      if (wasPlaying) {
+        const nextId = playAttemptIdRef.current + 1;
+        playAttemptIdRef.current = nextId;
+        playAttemptPendingRef.current = true;
+        setIsPlayPending(true);
+        setIsBuffering(true);
+      } else {
+        setIsPlaying(false);
+        setIsBuffering(false);
+      }
+      setIsPreparing(true);
+      setCanPlay(false);
+    }, [mse.mode, activeVideoSrc]);
+
     useEffect(() => {
       if (!resolvedVideoSrc) {
         setActiveVideoSrc(undefined);

package/corpus/templates/clips/app/lib/fmp4.ts

@@ -208,14 +208,36 @@ export function findMoofOffset(bytes: Uint8Array): number {
  * True when the head of an MP4 shows the fragmented shape: the `hlsf` brand in
  * `ftyp`, or an `mvex` box inside `moov` (present only in fragmented files).
  * `headBytes` should be the first few KB of the file.
+ *
+ * Both checks walk the ISO BMFF box structure rather than scanning raw bytes.
+ * Numeric fields inside moov children (timestamps, matrix values, codec config)
+ * can accidentally contain the byte sequences "mvex" or "hlsf", producing false
+ * positives if we just scan the whole buffer.
  */
 export function isFragmentedMp4Head(headBytes: Uint8Array): boolean {
   if (headBytes.byteLength < 8) return false;
-  // Must look like an MP4 at all.
+
   if (indexOfAscii(headBytes, "ftyp") !== 4) return false;
-  if (indexOfAscii(headBytes, "hlsf") !== -1) return true;
-  if (indexOfAscii(headBytes, "mvex") !== -1) return true;
-  return false;
+
+  const ftypSize = readU32(headBytes, 0);
+  if (ftypSize < 12) return false;
+  const ftypEnd = Math.min(ftypSize, headBytes.byteLength);
+
+  // Offset 12 is minor_version (uint32), not a brand — start compatible brands at 16.
+  if (ftypEnd >= 12 && readType(headBytes, 8) === "hlsf") return true;
+  for (let i = 16; i + 4 <= ftypEnd; i += 4) {
+    if (readType(headBytes, i) === "hlsf") return true;
+  }
+
+  const boxes = readTopLevelBoxes(headBytes);
+  const moov = boxes.find((b) => b.type === "moov");
+  if (!moov || moov.size === 0) return false;
+  const moovPayloadEnd = Math.min(moov.start + moov.size, headBytes.byteLength);
+  const moovPayload = headBytes.subarray(
+    moov.start + moov.headerSize,
+    moovPayloadEnd,
+  );
+  return readTopLevelBoxes(moovPayload).some((b) => b.type === "mvex");
 }
 
 /** Cache detection by URL identity so we sniff each asset only once. */

package/corpus/templates/clips/app/lib/mse-video-loader.ts

@@ -555,11 +555,22 @@ export class MseVideoLoader {
       headers: { Range: `bytes=${start}-${end}` },
       signal: controller.signal,
     });
-    // 416 means we asked past the end — treat as a clean end-of-stream.
-    if (res.status === 416) return { bytes: new Uint8Array(0), eof: true };
+    if (res.status === 416) {
+      // A 416 at an offset before the known file total means the backing object
+      // was replaced with a smaller compressed version while we were streaming.
+      // Throw so runPump's catch calls fail() -> onFatal -> native path recovery.
+      // When totalKnown is false (cross-origin CDN hides Content-Range), we
+      // cannot tell premature from real EOF so we keep the old safe-EOF behaviour.
+      if (this.totalKnown && start < this.totalBytes) {
+        throw new Error("Range 416 before known EOF: backing file replaced");
+      }
+      return { bytes: new Uint8Array(0), eof: true };
+    }
     if (!res.ok) {
       throw new Error(`Range request failed: ${res.status}`);
     }
+    // If the backing file shrank mid-response (ERR_CONTENT_LENGTH_MISMATCH),
+    // arrayBuffer() throws here, which also routes through fail() -> onFatal.
     const buffer = await res.arrayBuffer();
     const bytes = new Uint8Array(buffer);
 

package/corpus/templates/clips/changelog/2026-07-20-agent-summaries-use-bounded-transcript-context.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-20
+---
+
+Agent summaries use bounded transcript context

package/corpus/templates/clips/changelog/2026-07-20-clip-summaries-now-finish-without-sending-a-long-transcript-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-20
+---
+
+Clip summaries now finish without sending a long transcript through the agent chat

package/corpus/templates/clips/changelog/2026-07-20-clips-agents-only-discover-recordings-you-own-or-have-alread.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-20
+---
+
+Clips agents only discover recordings you own or have already viewed

package/corpus/templates/clips/changelog/2026-07-20-hosted-recordings-no-longer-start-with-an-impossible-buffered-upload.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-20
+---
+
+Hosted recordings now stop with a clear retryable storage message instead of failing later during chunk upload.

package/corpus/templates/clips/changelog/2026-07-20-meeting-recordings-now-offer-a-cleaner-transcript-view-with-.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-20
+---
+
+Meeting recordings now offer a cleaner transcript view with quick chat and browser actions.

package/corpus/templates/clips/changelog/2026-07-20-rewind-capture-status.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-20
+---
+
+Rewind now reports the same live capture status on Home and in Settings without mistaking an idle moment for a permission problem.

package/corpus/templates/clips/changelog/2026-07-20-shared-clips-can-be-shared-with-limited-access-and-cards-sho.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-20
+---
+
+Shared clips can be shared with limited access, and cards show who created them and when.

package/corpus/templates/clips/desktop/src/app.tsx

@@ -86,6 +86,7 @@ import {
   type RecorderStopResult,
 } from "./lib/recorder";
 import { REWIND_AGENT_PROMPT } from "./lib/rewind-agent-prompt";
+import { getRewindStatusPresentation } from "./lib/rewind-status";
 import {
   loadBool,
   loadString,
@@ -893,6 +894,7 @@ export function App() {
   const [homeScreenMemoryStatus, setHomeScreenMemoryStatus] =
     useState<ScreenMemoryStatus | null>(null);
   const [homeScreenMemoryBusy, setHomeScreenMemoryBusy] = useState(false);
+  const homeScreenMemoryRefreshVersionRef = useRef(0);
   const [rewindAgentPromptCopied, setRewindAgentPromptCopied] = useState(false);
   const [agentHandoff, setAgentHandoff] =
     useState<RewindAgentHandoffRequest | null>(null);
@@ -946,26 +948,54 @@ export function App() {
   const isRecording = recorder !== null;
   // Whether the popover window is shown; driven by the visibility effect below.
   const [popoverVisible, setPopoverVisible] = useState(false);
+  const homeRewindPresentation = getRewindStatusPresentation({
+    status: homeScreenMemoryStatus,
+    config: featureConfig?.screenMemory ?? DEFAULT_SCREEN_MEMORY_CONFIG,
+    clipRecordingActive: isRecording || recordingFlowActive,
+  });
+  const refreshHomeScreenMemoryStatus = useCallback(() => {
+    const version = ++homeScreenMemoryRefreshVersionRef.current;
+    invoke<ScreenMemoryStatus>("screen_memory_status")
+      .then((status) => {
+        if (version === homeScreenMemoryRefreshVersionRef.current) {
+          setHomeScreenMemoryStatus(status);
+        }
+      })
+      .catch(() => {});
+  }, []);
   useEffect(() => {
     if (featureConfig?.screenMemory?.enabled !== true) {
+      homeScreenMemoryRefreshVersionRef.current += 1;
       setHomeScreenMemoryStatus(null);
       return;
     }
     let cancelled = false;
     const refresh = () => {
-      invoke<ScreenMemoryStatus>("screen_memory_status")
-        .then((status) => {
-          if (!cancelled) setHomeScreenMemoryStatus(status);
-        })
-        .catch(() => {});
+      if (!cancelled) refreshHomeScreenMemoryStatus();
     };
     refresh();
     const timer = window.setInterval(refresh, popoverVisible ? 5_000 : 30_000);
+    let unlisten: (() => void) | undefined;
+    listen("clips:screen-memory-changed", refresh)
+      .then((stopListening) => {
+        if (cancelled) {
+          stopListening();
+          return;
+        }
+        unlisten = stopListening;
+      })
+      .catch(() => {});
     return () => {
       cancelled = true;
+      homeScreenMemoryRefreshVersionRef.current += 1;
       window.clearInterval(timer);
+      unlisten?.();
     };
-  }, [featureConfig?.screenMemory?.enabled, popoverVisible]);
+  }, [
+    featureConfig?.screenMemory?.enabled,
+    popoverVisible,
+    refreshHomeScreenMemoryStatus,
+  ]);
   const recordShortcutHandlerRef = useRef<() => void>(() => {});
   // Mirrors `bubbleActive` (assigned below once it is computed) so device
   // probes can synchronously tell whether the camera bubble owns the grant.
@@ -3154,8 +3184,11 @@ export function App() {
           },
         },
       });
-      const status = await invoke<ScreenMemoryStatus>("screen_memory_status");
-      setHomeScreenMemoryStatus(status);
+      // The native producer can take a moment to finish pausing. Do not keep
+      // the Home switch locked while that status request waits; the existing
+      // change event and bounded poll will reconcile it, and this best-effort
+      // refresh can do the same without blocking the next resume action.
+      refreshHomeScreenMemoryStatus();
     } catch (err) {
       console.error(
         "[clips-tray] update Rewind remembering state failed:",
@@ -3633,34 +3666,13 @@ export function App() {
         <section className="rewind-home-card" aria-label="Rewind status">
           <div className="rewind-home-status">
             <span
-              className={`rewind-home-dot ${
-                featureConfig?.screenMemory?.enabled === true &&
-                featureConfig.screenMemory.paused !== true &&
-                homeScreenMemoryStatus?.state === "recording"
-                  ? "is-live"
-                  : ""
-              }`}
+              className={`rewind-home-dot ${homeRewindPresentation.isLive ? "is-live" : ""}`}
             />
             <div>
-              <strong>
-                {featureConfig?.screenMemory?.enabled !== true
-                  ? "Rewind is off"
-                  : featureConfig.screenMemory.paused === true
-                    ? "Rewind is paused"
-                    : homeScreenMemoryStatus?.exclusionActive
-                      ? "Rewind is protecting a private moment"
-                      : "Rewind is remembering"}
-              </strong>
-              {featureConfig?.screenMemory?.enabled !== true ||
-              featureConfig.screenMemory.paused ||
-              homeScreenMemoryStatus?.exclusionActive ? (
-                <p>
-                  {featureConfig?.screenMemory?.enabled !== true
-                    ? "Private memory for moments you may need later."
-                    : featureConfig.screenMemory.paused
-                      ? "Existing local memory is still available."
-                      : "An excluded app is being skipped."}
-                </p>
+              <strong>{homeRewindPresentation.title}</strong>
+              {!homeRewindPresentation.isLive ||
+              homeRewindPresentation.hasError ? (
+                <p>{homeRewindPresentation.detail}</p>
               ) : null}
             </div>
             <div className="rewind-home-controls">
@@ -4941,6 +4953,7 @@ function Setup({
   );
   const [screenMemoryStatus, setScreenMemoryStatus] =
     useState<ScreenMemoryStatus | null>(null);
+  const screenMemoryStatusRefreshVersionRef = useRef(0);
   const [screenMemoryMessage, setScreenMemoryMessage] = useState<{
     kind: "ok" | "error";
     text: string;
@@ -4976,7 +4989,11 @@ function Setup({
     (sum, segment) => sum + segment.bytes,
     0,
   );
-  const screenMemoryRecording = screenMemoryStatus?.state === "recording";
+  const rewindStatusPresentation = getRewindStatusPresentation({
+    status: screenMemoryStatus,
+    config: screenMemory,
+    clipRecordingActive: recordingActive,
+  });
   const captureControlsLocked = recordingActive;
 
   useEffect(() => {
@@ -5172,11 +5189,16 @@ function Setup({
     }
   }
 
-  function refreshScreenMemoryStatus() {
+  const refreshScreenMemoryStatus = useCallback(() => {
+    const version = ++screenMemoryStatusRefreshVersionRef.current;
     invoke<ScreenMemoryStatus>("screen_memory_status")
-      .then(setScreenMemoryStatus)
+      .then((status) => {
+        if (version === screenMemoryStatusRefreshVersionRef.current) {
+          setScreenMemoryStatus(status);
+        }
+      })
       .catch(() => {});
-  }
+  }, []);
 
   function refreshRewindEgressLog() {
     invoke<RewindEgressEvent[]>("rewind_list_evidence_egress", { limit: 20 })
@@ -5257,6 +5279,7 @@ function Setup({
       const status = await invoke<ScreenMemoryStatus>(
         "screen_memory_delete_all",
       );
+      screenMemoryStatusRefreshVersionRef.current += 1;
       setScreenMemoryStatus(status);
       setScreenMemoryMessage({ kind: "ok", text: "Rewind cleared." });
     } catch (err) {
@@ -5424,13 +5447,10 @@ function Setup({
   useEffect(() => {
     let cancelled = false;
     const refresh = () => {
-      invoke<ScreenMemoryStatus>("screen_memory_status")
-        .then((status) => {
-          if (!cancelled) setScreenMemoryStatus(status);
-        })
-        .catch(() => {});
+      if (!cancelled) refreshScreenMemoryStatus();
     };
     refresh();
+    const timer = window.setInterval(refresh, 5_000);
     const unlistens: Array<() => void> = [];
     const track = (p: Promise<() => void>) => {
       p.then((u) => {
@@ -5448,6 +5468,8 @@ function Setup({
     track(listen("clips:screen-memory-changed", refresh));
     return () => {
       cancelled = true;
+      screenMemoryStatusRefreshVersionRef.current += 1;
+      window.clearInterval(timer);
       unlistens.forEach((u) => {
         try {
           u();
@@ -5456,7 +5478,7 @@ function Setup({
         }
       });
     };
-  }, []);
+  }, [refreshScreenMemoryStatus]);
 
   // Load model status on mount and keep it current via events.
   useEffect(() => {
@@ -6044,17 +6066,16 @@ function Setup({
             </div>
             <div className="rewind-settings-status">
               <span
-                className={`rewind-home-dot ${screenMemoryRecording ? "is-live" : ""}`}
+                className={`rewind-home-dot ${rewindStatusPresentation.isLive ? "is-live" : ""}`}
               />
-              <span>
-                {screenMemoryStatus?.exclusionActive
-                  ? screenMemoryStatus.coverage
-                  : screenMemoryRecording
+              <span className="rewind-settings-status-copy">
+                <strong>{rewindStatusPresentation.title}</strong>
+                <span>
+                  {rewindStatusPresentation.kind === "recording" &&
+                  !rewindStatusPresentation.hasError
                     ? `${screenMemorySegments.length} retained segment${screenMemorySegments.length === 1 ? "" : "s"} · ${formatStorageBytes(screenMemoryTotalBytes)}`
-                    : screenMemory.paused
-                      ? "Paused. Existing memory remains available."
-                      : screenMemoryStatus?.lastError ||
-                        "Waiting for screen-recording permission."}
+                    : rewindStatusPresentation.detail}
+                </span>
               </span>
             </div>
             <div className="setup-section-heading">Privacy</div>
@@ -6550,17 +6571,11 @@ function Setup({
       <div className="setup-section rewind-settings-entry">
         <div className="rewind-settings-entry-main">
           <span
-            className={`rewind-home-dot ${screenMemoryRecording ? "is-live" : ""}`}
+            className={`rewind-home-dot ${rewindStatusPresentation.isLive ? "is-live" : ""}`}
           />
           <div>
             <strong>Rewind</strong>
-            <p className="setup-hint">
-              {!screenMemory.enabled
-                ? "Off"
-                : screenMemory.paused
-                  ? "Paused · existing local memory is still available"
-                  : "Remembering locally"}
-            </p>
+            <p className="setup-hint">{rewindStatusPresentation.title}</p>
           </div>
         </div>
         <button type="button" className="secondary" onClick={onOpenRewind}>
@@ -6738,21 +6753,16 @@ function Setup({
               bundle ID cannot be detected.
             </p>
             <div className="whisper-status">
-              {screenMemoryRecording ? (
+              {rewindStatusPresentation.isLive ? (
                 <IconCircleCheck size={13} className="whisper-status-icon" />
               ) : (
                 <IconAlertTriangle size={13} className="whisper-status-icon" />
               )}
               <span>
-                {screenMemoryStatus?.exclusionActive
-                  ? screenMemoryStatus.coverage
-                  : screenMemoryRecording
-                    ? `Rewind is retaining local coverage: ${screenMemorySegments.length} segment${screenMemorySegments.length === 1 ? "" : "s"}, ${formatStorageBytes(screenMemoryTotalBytes)}.`
-                    : screenMemory.paused
-                      ? "Capture paused. Existing local coverage remains available."
-                      : screenMemoryStatus?.lastError
-                        ? screenMemoryStatus.lastError
-                        : "Capture status is waiting for screen-recording permission."}
+                {rewindStatusPresentation.kind === "recording" &&
+                !rewindStatusPresentation.hasError
+                  ? `Rewind is retaining local coverage: ${screenMemorySegments.length} segment${screenMemorySegments.length === 1 ? "" : "s"}, ${formatStorageBytes(screenMemoryTotalBytes)}.`
+                  : rewindStatusPresentation.detail}
               </span>
             </div>
             {screenMemorySegments[0] ? (

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

@@ -828,14 +828,18 @@ export function useMeetingTranscription({
     );
 
     unlistens.push(
-      listen<{ meetingId: string }>("clips:open-meeting", (ev) => {
-        if (!ev.payload?.meetingId) return;
-        openExternal(
-          `${normalizedServerUrl}/meetings/${ev.payload.meetingId}`,
-        ).catch((err) =>
-          console.warn("[clips-popover] open meeting in web failed:", err),
-        );
-      }),
+      listen<{ meetingId: string; openChat?: boolean }>(
+        "clips:open-meeting",
+        (ev) => {
+          if (!ev.payload?.meetingId) return;
+          const query = ev.payload.openChat ? "?chat=1" : "";
+          openExternal(
+            `${normalizedServerUrl}/meetings/${ev.payload.meetingId}${query}`,
+          ).catch((err) =>
+            console.warn("[clips-popover] open meeting in web failed:", err),
+          );
+        },
+      ),
     );
 
     return () => {

package/corpus/templates/clips/desktop/src/lib/rewind-status.ts

@@ -0,0 +1,103 @@
+import type { ScreenMemoryConfig, ScreenMemoryStatus } from "../shared/config";
+
+export type RewindPresentationKind =
+  | "off"
+  | "paused"
+  | "recording"
+  | "excluded"
+  | "idle"
+  | "error"
+  | "unavailable";
+
+export interface RewindStatusPresentation {
+  kind: RewindPresentationKind;
+  title: string;
+  detail: string;
+  isLive: boolean;
+  hasError: boolean;
+}
+
+export function getRewindStatusPresentation({
+  status,
+  config,
+  clipRecordingActive = false,
+}: {
+  status: ScreenMemoryStatus | null;
+  config: ScreenMemoryConfig;
+  clipRecordingActive?: boolean;
+}): RewindStatusPresentation {
+  const runtimeConfig = status?.config ?? config;
+
+  if (!runtimeConfig.enabled || status?.state === "disabled") {
+    return {
+      kind: "off",
+      title: "Rewind is off",
+      detail: "Private memory for moments you may need later.",
+      isLive: false,
+      hasError: false,
+    };
+  }
+
+  if (runtimeConfig.paused || status?.state === "paused") {
+    return {
+      kind: "paused",
+      title: "Rewind is paused",
+      detail: "Existing local memory is still available.",
+      isLive: false,
+      hasError: false,
+    };
+  }
+
+  if (status?.exclusionActive) {
+    return {
+      kind: "excluded",
+      title: "Rewind is protecting a private moment",
+      detail: status.coverage || "An excluded app is being skipped.",
+      isLive: false,
+      hasError: false,
+    };
+  }
+
+  if (status?.available === false) {
+    return {
+      kind: "unavailable",
+      title: "Rewind is unavailable",
+      detail: "Rewind capture is not available on this device.",
+      isLive: false,
+      hasError: false,
+    };
+  }
+
+  if (status?.state === "recording") {
+    return {
+      kind: "recording",
+      title: "Rewind is remembering",
+      detail:
+        status.lastError ||
+        status.coverage ||
+        "Rewind is retaining local coverage.",
+      isLive: true,
+      hasError: Boolean(status.lastError),
+    };
+  }
+
+  if (status?.lastError) {
+    return {
+      kind: "error",
+      title: "Rewind needs attention",
+      detail: status.lastError,
+      isLive: false,
+      hasError: true,
+    };
+  }
+
+  return {
+    kind: "idle",
+    title: "Rewind is enabled but not currently capturing",
+    detail: clipRecordingActive
+      ? "Rewind will resume when this Clip ends."
+      : "No new local coverage is being retained right now.",
+    isLive: false,
+    hasError: false,
+  };
+}

package/corpus/templates/clips/desktop/src/overlays/pill-logo.tsx

@@ -9,25 +9,12 @@ export function PillLogo({ className }: { className?: string }) {
     >
       <path
         d="M24.5537 65.7695H0L15.0859 39.4619L37.708 0L60.4912 39.4619H39.6396L24.5537 65.7695Z"
-        fill="white"
+        fill="currentColor"
       />
       <path
         d="M89.446 0H114L76.2921 65.7704H51.7383L89.446 0Z"
-        fill="url(#pill-logo-grad)"
+        fill="currentColor"
       />
-      <defs>
-        <linearGradient
-          id="pill-logo-grad"
-          x1="101.702"
-          y1="67.4791"
-          x2="113.672"
-          y2="-37.4275"
-          gradientUnits="userSpaceOnUse"
-        >
-          <stop stopColor="#00B5FF" />
-          <stop offset="1" stopColor="#48FFE4" />
-        </linearGradient>
-      </defs>
     </svg>
   );
 }