@kortix/ui 0.14.4 → 0.14.5

package/dist/internal/hooks/use-notification-center.js

@@ -1,6 +1,6 @@
 'use client';
 import { qk, useFeatureFlag } from '@kortix/sdk/react';
-import { useQuery, useQueryClient } from '@tanstack/react-query';
+import { useQueryClient } from '@tanstack/react-query';
 import { useCallback, useState, useSyncExternalStore } from 'react';
 export const NOTIFICATION_CENTER_FLAG = 'notification_center';
 /** The predicate of `useFeatureFlag`: the server said exactly `true`. */
@@ -50,14 +50,14 @@ export function anyCachedNotificationCenter(client) {
     return client.getQueryCache().getAll().some(holdsFlagOn);
 }
 /**
- * `anyCachedNotificationCenter`, reactive. Subscribes to the cache only while
- * `scan`. The cache reports synchronously, also when another component's
+ * A `useSyncExternalStore` subscription to the query cache, live only while
+ * `active`. The cache reports synchronously, also when another component's
  * `useQuery` builds its query during render; the re-check waits for a
  * microtask so this component never updates in the middle of that render.
  */
-function useAnyCachedNotificationCenter(client, scan) {
-    const subscribe = useCallback((onChange) => {
-        if (!scan)
+function useCacheSubscription(client, active) {
+    return useCallback((onChange) => {
+        if (!active)
             return () => { };
         let live = true;
         const unsubscribe = client.getQueryCache().subscribe(() => {
@@ -70,8 +70,11 @@ function useAnyCachedNotificationCenter(client, scan) {
             live = false;
             unsubscribe();
         };
-    }, [client, scan]);
-    return useSyncExternalStore(subscribe, () => scan && anyCachedNotificationCenter(client), () => false);
+    }, [client, active]);
+}
+/** `anyCachedNotificationCenter`, reactive. Subscribes to the cache only while `scan`. */
+function useAnyCachedNotificationCenter(client, scan) {
+    return useSyncExternalStore(useCacheSubscription(client, scan), () => scan && anyCachedNotificationCenter(client), () => false);
 }
 /** Is the notification center on for `projectId`, or, without one, for any cached project. */
 export function useNotificationCenter(projectId) {
@@ -88,14 +91,17 @@ export function useNotificationCenter(projectId) {
  * load of a project page starts off.
  */
 export function useNotificationHostGate(projectId) {
-    // The global host sits outside the access boundary. Observe the shell's
-    // detail entry without starting a request for a potentially revoked project.
-    const detail = useQuery({
-        queryKey: qk.project.detail(projectId ?? ''),
-        enabled: false,
-    });
-    const flag = { isLoading: detail.isPending, enabled: notificationCenterOn(detail.data?.project) };
     const client = useQueryClient();
+    // The global host sits outside the access boundary. Read the shell's detail
+    // entry from the cache: no request for a potentially revoked project, and no
+    // observer. An observer added a detail query without a queryFn (also for the
+    // empty id of a page outside any project), and every refetch of it logged
+    // "No queryFn was passed".
+    const detail = useSyncExternalStore(useCacheSubscription(client, !!projectId), () => (projectId ? client.getQueryState(qk.project.detail(projectId)) : undefined), () => undefined);
+    const flag = {
+        isLoading: !detail || detail.status === 'pending',
+        enabled: notificationCenterOn(detail?.data?.project),
+    };
     const anyProject = useAnyCachedNotificationCenter(client, !projectId);
     const [previous, setPrevious] = useState(false);
     let answer = anyProject;

package/dist/internal/hooks/use-review-session-summary.d.ts

@@ -51,3 +51,9 @@ export declare function useIsNeedsInputPoller(projectId: string): boolean;
  * `ProjectSessionList` alone still sees open questions.
  */
 export declare function useSessionNeedsYouCounts(projectId: string): Record<string, number>;
+/**
+ * Sessions with an open agent question or a pending connector approval: the
+ * `needs-you` rows that wait on an answer rather than a change request. Reads
+ * the cache `useSessionNeedsYouCounts` already polls, so it adds no request.
+ */
+export declare function useSessionsAwaitingAnswer(projectId: string): ReadonlySet<string>;

package/dist/internal/hooks/use-review-session-summary.js

@@ -82,3 +82,14 @@ export function useSessionNeedsYouCounts(projectId) {
     const { data: needsInput } = useSessionsNeedingInput(projectId, { enabled: poller });
     return useMemo(() => withNeedsInput(needsYouBySession, needsInput), [needsYouBySession, needsInput]);
 }
+/**
+ * Sessions with an open agent question or a pending connector approval: the
+ * `needs-you` rows that wait on an answer rather than a change request. Reads
+ * the cache `useSessionNeedsYouCounts` already polls, so it adds no request.
+ */
+export function useSessionsAwaitingAnswer(projectId) {
+    const { data } = useSessionsNeedingInput(projectId, { enabled: false });
+    return useMemo(() => new Set(Object.entries(data?.sessions ?? {})
+        .filter(([, count]) => count > 0)
+        .map(([sessionId]) => sessionId)), [data]);
+}

package/dist/internal/lib/browser-error-noise.d.ts

@@ -10,7 +10,7 @@ export { isConnectionClosedNoise, isFailedToSendMessageNoise, isFramelessNetwork
 export { isIosWebViewInjectedStackOverflowNoise, isOldBrowserDomNullDerefNoise, isFirefoxDeadObjectUnattributableNoise, isOldBrowserSyntaxParseError, isOldWebkitRegexNoiseMessage, isUndefinedVariableThirdPartyNoise, isUnresolvableStackOverflowNoise, } from './browser-noise/rules/old-browsers.js';
 export { isEmbedPdfTilingReactUpdateDepthNoise, isEmbedPdfTilingTileDestructureNoise, } from './browser-noise/rules/pdf.js';
 export { isDocumentStateNotFoundNoise, isExpectedNextRecoveryBailoutNoise, isFirefoxReactSchedulerReentryNoise, isLikelyDomMutationNoise, isServerSuspenseBailoutNoise, isThirdPartyReactUpdateDepthNoise, } from './browser-noise/rules/react.js';
-export { isAnonymousAuthRefreshRace, isAutoplayNotAllowedRejectionNoise, isNonErrorObjectNotFoundRejectionNoise, isNonErrorUndefinedRejectionNoise, isOperationErrorPopErrorScopeNoise, isSupabaseTokenExpiredNoise, } from './browser-noise/rules/rejections.js';
+export { isAnonymousAuthRefreshRace, isAutoplayNotAllowedRejectionNoise, isNonErrorObjectNotFoundRejectionNoise, isNonErrorUndefinedRejectionNoise, isOperationErrorPopErrorScopeNoise, isPlayNotSupportedRejectionNoise, isSupabaseTokenExpiredNoise, } from './browser-noise/rules/rejections.js';
 export { isSafariGenericSecurityErrorNoise, isStorageDisabledWebViewNoiseMessage, isStorageSecurityErrorNoise, } from './browser-noise/rules/storage.js';
 export { isAndroidWebViewNativeBridgePostEventNoise, isAndroidWebViewNativeBridgePostMessageNoise, isIOSWebViewWebKitBridgeNoise, } from './browser-noise/rules/webview.js';
 export declare const NOISE_RULES: readonly NoiseRule[];

package/dist/internal/lib/browser-error-noise.js

@@ -35,7 +35,7 @@ export { isConnectionClosedNoise, isFailedToSendMessageNoise, isFramelessNetwork
 export { isIosWebViewInjectedStackOverflowNoise, isOldBrowserDomNullDerefNoise, isFirefoxDeadObjectUnattributableNoise, isOldBrowserSyntaxParseError, isOldWebkitRegexNoiseMessage, isUndefinedVariableThirdPartyNoise, isUnresolvableStackOverflowNoise, } from './browser-noise/rules/old-browsers.js';
 export { isEmbedPdfTilingReactUpdateDepthNoise, isEmbedPdfTilingTileDestructureNoise, } from './browser-noise/rules/pdf.js';
 export { isDocumentStateNotFoundNoise, isExpectedNextRecoveryBailoutNoise, isFirefoxReactSchedulerReentryNoise, isLikelyDomMutationNoise, isServerSuspenseBailoutNoise, isThirdPartyReactUpdateDepthNoise, } from './browser-noise/rules/react.js';
-export { isAnonymousAuthRefreshRace, isAutoplayNotAllowedRejectionNoise, isNonErrorObjectNotFoundRejectionNoise, isNonErrorUndefinedRejectionNoise, isOperationErrorPopErrorScopeNoise, isSupabaseTokenExpiredNoise, } from './browser-noise/rules/rejections.js';
+export { isAnonymousAuthRefreshRace, isAutoplayNotAllowedRejectionNoise, isNonErrorObjectNotFoundRejectionNoise, isNonErrorUndefinedRejectionNoise, isOperationErrorPopErrorScopeNoise, isPlayNotSupportedRejectionNoise, isSupabaseTokenExpiredNoise, } from './browser-noise/rules/rejections.js';
 export { isSafariGenericSecurityErrorNoise, isStorageDisabledWebViewNoiseMessage, isStorageSecurityErrorNoise, } from './browser-noise/rules/storage.js';
 export { isAndroidWebViewNativeBridgePostEventNoise, isAndroidWebViewNativeBridgePostMessageNoise, isIOSWebViewWebKitBridgeNoise, } from './browser-noise/rules/webview.js';
 export const NOISE_RULES = [

package/dist/internal/lib/browser-noise/rules/rejections.d.ts

@@ -127,4 +127,14 @@ export declare function isAutoplayNotAllowedRejectionNoise(input: {
         filename?: unknown;
     } | undefined>;
 }): boolean;
+/**
+ * Whether a Sentry event is the frameless `HTMLMediaElement.play()`
+ * `NotSupportedError` rejection. See `PLAY_NOT_SUPPORTED_PATTERN`.
+ */
+export declare function isPlayNotSupportedRejectionNoise(input: {
+    message?: unknown;
+    frames?: Array<{
+        filename?: unknown;
+    } | undefined>;
+}): boolean;
 export declare const REJECTION_RULES: readonly NoiseRule[];

package/dist/internal/lib/browser-noise/rules/rejections.js

@@ -479,7 +479,28 @@ export function isAutoplayNotAllowedRejectionNoise(input) {
     if (!PLAY_NOT_ALLOWED_PATTERN.test(message)) {
         return false;
     }
-    const frames = input.frames ?? [];
+    return isUnattributablePlayRejection(input.frames);
+}
+// Firefox's `NotSupportedError` for a play() promise whose element has no
+// playable source. Better Stack pattern
+// 1b3195a99afc344886a33243b1b73942b94e74c6bf5ca6b561d3bddc3e3289c6
+// (Kortix Frontend prod, application_id 2346967, KRTX-2998): 1 occurrence, 0
+// identified users, first=last 2026-10-21T09:54:06Z, call site unknown. Every
+// first-party play() promise attaches a `.catch` (`film.tsx`, `sounds.ts`,
+// `video-renderer.tsx`), so the frameless capture is not ours. The guards of
+// `isAutoplayNotAllowedRejectionNoise` keep an attributable one reporting.
+const PLAY_NOT_SUPPORTED_PATTERN = /^The media resource indicated by the src attribute or assigned media provider object was not suitable\.$/;
+/**
+ * Whether a Sentry event is the frameless `HTMLMediaElement.play()`
+ * `NotSupportedError` rejection. See `PLAY_NOT_SUPPORTED_PATTERN`.
+ */
+export function isPlayNotSupportedRejectionNoise(input) {
+    if (!PLAY_NOT_SUPPORTED_PATTERN.test(normalizeString(input.message))) {
+        return false;
+    }
+    return isUnattributablePlayRejection(input.frames);
+}
+function isUnattributablePlayRejection(frames = []) {
     // Negative guard #1: a resolved first-party `apps/web/src/…` frame means
     // our own code left a play promise unhandled → actionable; keep reporting
     // so the call site can be found + given its `.catch`.
@@ -501,6 +522,11 @@ export const REJECTION_RULES = [
         appliesTo: 'sentry',
         match: isAutoplayNotAllowedRejectionNoise,
     },
+    {
+        id: 'play-not-supported',
+        appliesTo: 'sentry',
+        match: isPlayNotSupportedRejectionNoise,
+    },
     {
         id: 'non-error-undefined-rejection',
         appliesTo: 'sentry',

package/dist/internal/lib/provider-branding.js

@@ -100,6 +100,10 @@ const CATALOG_PROVIDER_IDS = new Set(CATALOG_PROVIDER_ENV.map((provider) => prov
  * (a custom provider) keeps initials.
  */
 export function providerIconSrc(providerID, baseUrl) {
+    // Drawn in code (ProviderLogo), never fetched: models.dev has no Platinum logo
+    // and answers with its generic sparkles mark.
+    if (providerID === 'platinum')
+        return undefined;
     const icon = PROVIDER_ICON_MAP[providerID]?.icon;
     if (icon)
         return baseUrl === undefined ? `https://models.dev/logos/${icon}.svg` : `${baseUrl}/${icon}.svg`;
@@ -144,7 +148,8 @@ export function ProviderLogo({ providerID, name, className, size = 'default', to
     // An unreachable models.dev logo (offline self-host) falls back to initials.
     const [failedSrc, setFailedSrc] = useState();
     const kortix = providerID === 'kortix';
-    const iconSrc = kortix ? undefined : providerIconSrc(providerID, providerIconBaseUrl);
+    const platinum = providerID === 'platinum';
+    const iconSrc = kortix || platinum ? undefined : providerIconSrc(providerID, providerIconBaseUrl);
     const src = iconSrc === failedSrc ? undefined : iconSrc;
     const sizeClasses = {
         xs: 'size-4',
@@ -166,10 +171,16 @@ export function ProviderLogo({ providerID, name, className, size = 'default', to
         // the other sizes read as an avatar, and at 16px a tile around a 12px
         // mark is all frame and no logo. The initials fallback keeps its tile
         // at every size: two bare letters at 9px read as debris, not a logo.
-        (src || kortix) && size === 'xs' ? 'bg-transparent' : light ? LOGO_TILE_LIGHT : 'bg-muted rounded-md', sizeClasses[size], className), "aria-hidden": "true", children: kortix ? (
+        (src || kortix || platinum) && size === 'xs' ? 'bg-transparent' : light ? LOGO_TILE_LIGHT : 'bg-muted rounded-md', sizeClasses[size], className), "aria-hidden": "true", children: kortix ? (
         // The host's brand mark (`useBrand` icon), else the Kortix symbol in currentColor.
         _jsx(KortixLogo, { variant: "icon", style: {
                 width: `calc(var(--spacing) * ${KORTIX_MARK_STEPS[size]})`,
                 height: `calc(var(--spacing) * ${KORTIX_MARK_STEPS[size]})`,
-            }, className: light ? LOGO_TILE_LIGHT_TEXT : 'text-foreground' })) : src ? (_jsx(Image, { src: src, alt: "", width: iconSizes[size], height: iconSizes[size], unoptimized: src.startsWith('https:'), onError: () => setFailedSrc(src), className: cn('object-contain', !light && 'dark:invert') })) : (_jsx("span", { className: cn('font-semibold tracking-wide uppercase', light ? LOGO_TILE_LIGHT_TEXT : 'text-muted-foreground', size === 'xs' ? 'text-[9px]' : 'text-xs'), children: initialsFor(providerID, name) })) }));
+            }, className: light ? LOGO_TILE_LIGHT_TEXT : 'text-foreground' })) : platinum ? (
+        // The Platinum mark (platinum.dev/brand): a flat square in currentColor,
+        // the favicon geometry — 14 of 24, inset 5.
+        _jsx("svg", { viewBox: "0 0 24 24", style: {
+                width: `calc(var(--spacing) * ${KORTIX_MARK_STEPS[size] + 2})`,
+                height: `calc(var(--spacing) * ${KORTIX_MARK_STEPS[size] + 2})`,
+            }, className: light ? LOGO_TILE_LIGHT_TEXT : 'text-foreground', children: _jsx("rect", { x: "5", y: "5", width: "14", height: "14", fill: "currentColor" }) })) : src ? (_jsx(Image, { src: src, alt: "", width: iconSizes[size], height: iconSizes[size], unoptimized: src.startsWith('https:'), onError: () => setFailedSrc(src), className: cn('object-contain', !light && 'dark:invert') })) : (_jsx("span", { className: cn('font-semibold tracking-wide uppercase', light ? LOGO_TILE_LIGHT_TEXT : 'text-muted-foreground', size === 'xs' ? 'text-[9px]' : 'text-xs'), children: initialsFor(providerID, name) })) }));
 }

package/dist/internal/lib/trigger-clock.d.ts

@@ -0,0 +1,42 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+import type { UiTranslator } from '../../i18n/index.js';
+import type { ProjectTrigger } from '@kortix/sdk';
+/**
+ * The trigger clock's health tones and its "last run" label. The Triggers list
+ * (`customize/triggers/schedule`) and the session reminders panel
+ * (`session/panel`) both draw them, so they sit below both layers.
+ */
+export type ClockState = 'ok' | 'failed' | 'needs_connection' | 'pending' | 'paused' | 'never';
+/**
+ * ONE tone per state drives both the reflection and the dot, so they cannot
+ * disagree. Three colours, always full strength: green = live (running, ran,
+ * or not run yet), red = failed, yellow = paused or waiting on setup.
+ */
+export declare const CLOCK_TONE: {
+    readonly ok: {
+        readonly reflection: "text-kortix-green";
+        readonly dot: "bg-kortix-green";
+    };
+    readonly never: {
+        readonly reflection: "text-kortix-green";
+        readonly dot: "bg-kortix-green";
+    };
+    readonly failed: {
+        readonly reflection: "text-kortix-red";
+        readonly dot: "bg-kortix-red";
+    };
+    readonly needs_connection: {
+        readonly reflection: "text-kortix-yellow";
+        readonly dot: "bg-kortix-yellow";
+    };
+    readonly pending: {
+        readonly reflection: "text-kortix-yellow";
+        readonly dot: "bg-kortix-yellow";
+    };
+    readonly paused: {
+        readonly reflection: "text-kortix-yellow";
+        readonly dot: "bg-kortix-yellow";
+    };
+};
+/** "2d ago", "9h ago", "3w ago" in the viewer's locale, or "Never run". */
+export declare function lastRunLabel(trigger: Pick<ProjectTrigger, 'last_fired_at' | 'event'>, t: UiTranslator, locale: string, now?: number): string;

package/dist/internal/lib/trigger-clock.js

@@ -0,0 +1,34 @@
+const GREEN = { reflection: 'text-kortix-green', dot: 'bg-kortix-green' };
+const RED = { reflection: 'text-kortix-red', dot: 'bg-kortix-red' };
+const YELLOW = { reflection: 'text-kortix-yellow', dot: 'bg-kortix-yellow' };
+/**
+ * ONE tone per state drives both the reflection and the dot, so they cannot
+ * disagree. Three colours, always full strength: green = live (running, ran,
+ * or not run yet), red = failed, yellow = paused or waiting on setup.
+ */
+export const CLOCK_TONE = {
+    ok: GREEN,
+    never: GREEN,
+    failed: RED,
+    needs_connection: YELLOW,
+    pending: YELLOW,
+    paused: YELLOW,
+};
+/** "2d ago", "9h ago", "3w ago" in the viewer's locale, or "Never run". */
+export function lastRunLabel(trigger, t, locale, now = Date.now()) {
+    const iso = trigger.last_fired_at ?? trigger.event?.last_event_at ?? null;
+    const at = iso ? Date.parse(iso) : Number.NaN;
+    if (!Number.isFinite(at))
+        return t.raw('text3d40a69d3160');
+    const rtf = new Intl.RelativeTimeFormat(locale, { style: 'narrow', numeric: 'auto' });
+    const min = Math.floor(Math.max(0, now - at) / 60_000);
+    if (min < 1)
+        return rtf.format(0, 'second');
+    if (min < 60)
+        return rtf.format(-min, 'minute');
+    if (min < 24 * 60)
+        return rtf.format(-Math.floor(min / 60), 'hour');
+    if (min < 7 * 24 * 60)
+        return rtf.format(-Math.floor(min / (24 * 60)), 'day');
+    return rtf.format(-Math.floor(min / (7 * 24 * 60)), 'week');
+}

package/dist/internal/lib/web-notifications.d.ts

@@ -36,6 +36,12 @@ export interface WebNotificationPayload {
     preview?: string;
     /** Localized "Open session" for the finished-turn toast. */
     openSessionLabel?: string;
+    /** The open change request the finished turn produced: the toast offers Review. */
+    changeRequest?: {
+        crId: string;
+        detail: string;
+        reviewLabel: string;
+    };
     /** Localized "{count} tasks finished" for the stack several turns collapse into. */
     stackTitle?: (count: number) => string;
     /** A row of the notification inbox. Inbox rows exist only for projects with `notification_center` on. */

package/dist/internal/lib/web-notifications.js

@@ -31,7 +31,7 @@ import { createElement } from 'react';
 import { cachedNotificationCenter, cachedNotificationCenterAnswer, } from '../hooks/use-notification-center.js';
 import { hasWebPushSubscription } from '../notifications/web-push.js';
 import { customToast, dismissToast, ToastCard, toastIcon, errorToast, infoToast, successToast, warningToast, } from '../../primitives/toast.js';
-import { ClockIcon } from '@phosphor-icons/react';
+import { ClockIcon, GitPullRequestIcon } from '@phosphor-icons/react';
 import { SessionFailedCard, SessionStackCard, } from '../notifications/session-toast-cards.js';
 import { logger } from './logger.js';
 import { softNavigate } from './navigation/router-bridge.js';
@@ -42,7 +42,7 @@ import { playSound } from './sounds.js';
 import { openTabAndNavigate, useTabStore } from '../stores/tab-store.js';
 import { useTurnAttentionStore } from '../stores/turn-attention-store.js';
 import { useWebNotificationStore } from '../stores/web-notification-store.js';
-import { normalizeAppPathname } from '@kortix/sdk';
+import { listChangeRequests, normalizeAppPathname, } from '@kortix/sdk';
 // ============================================================================
 // Server push preference
 // ============================================================================
@@ -138,7 +138,7 @@ function navigateToSession(sessionId, sessionTitle, opts) {
     const projectId = opts?.projectId ?? currentProjectId();
     if (!projectId)
         return;
-    const href = projectSessionHref(projectId, sessionId);
+    const href = projectSessionHref(projectId, sessionId) + (opts?.search ?? '');
     try {
         // Open/activate the tab in the tab store + pushState
         openTabAndNavigate({
@@ -497,6 +497,15 @@ function showSessionToast(payload, sessionId) {
     // focus) names nothing and opens nothing: the person is already there.
     // Read at render, so it follows where the person is now.
     const elsewhere = () => !isViewingSession(sessionId);
+    const cr = payload.changeRequest;
+    // `?cr=` opens the change request's review dialog on the session page.
+    const review = () => {
+        navigateToSession(sessionId, payload.body, {
+            projectId: payload.projectId,
+            search: cr ? `?cr=${encodeURIComponent(cr.crId)}` : undefined,
+        });
+        payload.onClick?.();
+    };
     if (item.failed) {
         customToast((dismiss) => createElement(SessionFailedCard, {
             title: payload.inAppTitle ?? payload.title,
@@ -512,12 +521,23 @@ function showSessionToast(payload, sessionId) {
         message: payload.inAppTitle ?? payload.title,
         icon: toastIcon('success'),
         variant: 'success',
+        // On the session itself the change request card is in the transcript,
+        // so the toast only says it is there.
         options: elsewhere()
             ? {
-                entity: { label: item.label },
-                actions: [{ label: payload.openSessionLabel ?? openLabel, onClick: () => open(item) }],
+                entity: {
+                    icon: cr ? createElement(GitPullRequestIcon, { className: 'size-3.5' }) : undefined,
+                    label: item.label,
+                },
+                description: cr?.detail,
+                actions: [
+                    ...(cr ? [{ label: cr.reviewLabel, onClick: review }] : []),
+                    { label: payload.openSessionLabel ?? openLabel, onClick: () => open(item) },
+                ],
             }
-            : undefined,
+            : cr
+                ? { description: cr.detail }
+                : undefined,
         onDismiss: dismiss,
     }), { id, duration: NOTIFICATION_VISIBLE_MS, onClose });
 }
@@ -576,7 +596,7 @@ export function notifyTaskCompleteFor({ sessionId, sessionTitle, projectId, noti
     noteTurnCompleteShown(sessionId);
     const name = sessionDisplayName(sessionTitle, sessionId);
     const label = sessionTitle ? `"${name.slice(0, 60)}"` : name;
-    sendWebNotification({
+    const payload = {
         type: 'completion',
         entityLabel: name,
         openSessionLabel: tI18nComplete.raw('textb205bb47f81a'),
@@ -591,8 +611,38 @@ export function notifyTaskCompleteFor({ sessionId, sessionTitle, projectId, noti
         // deep link (the same rule the click-time path documents above).
         projectId,
         notificationCenter,
+    };
+    if (!projectId) {
+        sendWebNotification(payload);
+        return;
+    }
+    void openChangeRequestOf(projectId, sessionId).then((cr) => {
+        if (!cr) {
+            sendWebNotification(payload);
+            return;
+        }
+        const detail = tI18nComplete('text57f57edb6f16', { number: cr.number });
+        sendWebNotification({
+            ...payload,
+            body: `${payload.body} ${detail}`,
+            changeRequest: { crId: cr.cr_id, detail, reviewLabel: tI18nComplete.raw('textaff0766a5290') },
+        });
     });
 }
+/** How long the finished-turn toast waits for the change request lookup. */
+const CHANGE_REQUEST_LOOKUP_MS = 2_500;
+/**
+ * The newest open change request the session opened, or null. Server-vouched
+ * by `origin_session_id`, the same rule as the transcript's change request card.
+ * A slow or failed lookup answers null, so the toast never waits on it for long.
+ */
+function openChangeRequestOf(projectId, sessionId) {
+    const lookup = listChangeRequests(projectId, 'open', { originSessionId: sessionId, limit: 1 })
+        .then((page) => page.change_requests[0] ?? null)
+        .catch(() => null);
+    const timeout = new Promise((resolve) => setTimeout(() => resolve(null), CHANGE_REQUEST_LOOKUP_MS));
+    return Promise.race([lookup, timeout]);
+}
 /**
  * Notify that a session encountered an error.
  */

package/dist/internal/notifications/notification-bell.d.ts

@@ -14,6 +14,19 @@ export interface NotificationPanelProps {
 }
 /** Props only: the header, the All / Needs you / Done tabs, the rows, and the footer offer. */
 export declare function NotificationPanel({ rows, state, unreadCount, prompt, onOpenRow, onMarkAllRead, onRetry, onTurnOn, onDismissPrompt, }: NotificationPanelProps): import("react").JSX.Element;
+/**
+ * The bell (Paper B12 in the toast's badge-glow style): the glyph muted, then
+ * again in the badge's colour under `BELL_REFLECTION_MASK`, so the
+ * colour reaches in from the corner the count sits on, as `EntityTile` in
+ * `components/ui/toast.tsx` and `TriggerTile` draw it. Yellow when something
+ * waits on the person (the Needs you tab), blue otherwise.
+ */
+/**
+ * The toast's `REFLECTION_MASK` scaled from its 20px icon to the 16px bell
+ * (16px → 12px), centred on the glyph's bottom-right corner where the count
+ * sits. At full size it would tint the whole bell.
+ */
+export declare const BELL_REFLECTION_MASK = "radial-gradient(circle 12px at 100% 100%, #000 35%, transparent 100%)";
 export declare function BellMark({ count, needsYou, surface, }: {
     count: number;
     needsYou: boolean;

package/dist/internal/notifications/notification-bell.js

@@ -78,7 +78,7 @@ export function NotificationPanel({ rows, state, unreadCount, prompt, onOpenRow,
  * (16px → 12px), centred on the glyph's bottom-right corner where the count
  * sits. At full size it would tint the whole bell.
  */
-const BELL_REFLECTION_MASK = 'radial-gradient(circle 12px at 100% 100%, #000 35%, transparent 100%)';
+export const BELL_REFLECTION_MASK = 'radial-gradient(circle 12px at 100% 100%, #000 35%, transparent 100%)';
 export function BellMark({ count, needsYou, surface = 'bg-background', }) {
     const tone = needsYou
         ? { reflection: 'text-kortix-yellow', disc: 'bg-kortix-yellow' }

package/dist/internal/reminders/reminder-filter.d.ts

@@ -0,0 +1,12 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+import type { SessionReminder } from '@kortix/sdk';
+export type ReminderStatusFilter = 'all' | 'active' | 'paused' | 'failed';
+/** By next run: within the hour, the day, the week, or later than a week. */
+export type ReminderTimeFilter = 'any' | 'hour' | 'day' | 'week' | 'later';
+export declare const REMINDER_STATUS_FILTERS: readonly ReminderStatusFilter[];
+export declare const REMINDER_TIME_FILTERS: readonly ReminderTimeFilter[];
+export declare function matchesStatus(reminder: SessionReminder, status: ReminderStatusFilter): boolean;
+/** A time filter other than `any` keeps only active reminders: a paused one has no next run. */
+export declare function matchesTime(reminder: SessionReminder, time: ReminderTimeFilter, now: number): boolean;
+/** Every word of the query appears in the title, the prompt or the schedule label. */
+export declare function matchesQuery(reminder: SessionReminder, query: string, schedule: string): boolean;

package/dist/internal/reminders/reminder-filter.js

@@ -0,0 +1,34 @@
+export const REMINDER_STATUS_FILTERS = ['all', 'active', 'paused', 'failed'];
+export const REMINDER_TIME_FILTERS = ['any', 'hour', 'day', 'week', 'later'];
+const HOUR = 60 * 60 * 1000;
+const WINDOW_MS = {
+    hour: HOUR,
+    day: 24 * HOUR,
+    week: 7 * 24 * HOUR,
+};
+export function matchesStatus(reminder, status) {
+    if (status === 'all')
+        return true;
+    if (status === 'failed')
+        return reminder.last_status === 'failed';
+    return status === 'active' ? reminder.state === 'active' : reminder.state !== 'active';
+}
+/** A time filter other than `any` keeps only active reminders: a paused one has no next run. */
+export function matchesTime(reminder, time, now) {
+    if (time === 'any')
+        return true;
+    const next = reminder.state === 'active' && reminder.next_fire_at ? Date.parse(reminder.next_fire_at) : NaN;
+    if (!Number.isFinite(next))
+        return false;
+    if (time === 'later')
+        return next - now > WINDOW_MS.week;
+    return next - now <= WINDOW_MS[time];
+}
+/** Every word of the query appears in the title, the prompt or the schedule label. */
+export function matchesQuery(reminder, query, schedule) {
+    const words = query.trim().toLowerCase().split(/\s+/).filter(Boolean);
+    if (words.length === 0)
+        return true;
+    const haystack = [reminder.name, reminder.prompt, schedule].filter(Boolean).join(' ').toLowerCase();
+    return words.every((word) => haystack.includes(word));
+}

package/dist/internal/reminders/reminder-format.d.ts

@@ -14,6 +14,12 @@ export declare function formatFireTime(iso: string, locale: string, now: number)
  */
 export declare function nearestFire(reminders: readonly Pick<SessionReminder, 'state' | 'next_fire_at' | 'last_fired_at' | 'at'>[]): number | null;
 export declare function soonestFire(reminders: readonly Pick<SessionReminder, 'state' | 'next_fire_at'>[]): number | null;
+/**
+ * How much of the wait before the next fire has passed, 0..1: the interval of
+ * an `every` reminder, else the span since the last fire (or creation). Null
+ * when there is no next fire to count toward.
+ */
+export declare function elapsedShare(reminder: Pick<SessionReminder, 'next_fire_at' | 'every_seconds' | 'last_fired_at' | 'created_at'>, now: number): number | null;
 /** The first line of the reminder text, for a one-line row title. */
 export declare function reminderTitle(reminder: Pick<SessionReminder, 'name' | 'prompt'>): string;
 /** "Cron 0 9 * * * Europe/Berlin", "Every 1h" or "Once"; `t` is the `reminders` translator. */

package/dist/internal/reminders/reminder-format.js

@@ -10,10 +10,12 @@ export function formatFireTime(iso, locale, now) {
     const deltaMin = Math.round((at - now) / 60_000);
     const rtf = new Intl.RelativeTimeFormat(locale, { numeric: 'auto', style: 'short' });
     const abs = Math.abs(deltaMin);
+    // `short` abbreviates with a period ("in 32 min."); a row's trailing label reads cleaner without it.
+    const relative = (value, unit) => rtf.format(value, unit).replace(/\.(?=\s|$)/g, '');
     if (abs < 60)
-        return rtf.format(deltaMin, 'minute');
+        return relative(deltaMin, 'minute');
     if (abs < 24 * 60)
-        return rtf.format(Math.round(deltaMin / 60), 'hour');
+        return relative(Math.round(deltaMin / 60), 'hour');
     const date = new Date(at);
     if (deltaMin > 0 && deltaMin < 7 * 24 * 60) {
         return date.toLocaleString(locale, { weekday: 'short', hour: '2-digit', minute: '2-digit' });
@@ -60,6 +62,22 @@ export function soonestFire(reminders) {
     }
     return soonest;
 }
+/**
+ * How much of the wait before the next fire has passed, 0..1: the interval of
+ * an `every` reminder, else the span since the last fire (or creation). Null
+ * when there is no next fire to count toward.
+ */
+export function elapsedShare(reminder, now) {
+    const next = reminder.next_fire_at ? Date.parse(reminder.next_fire_at) : NaN;
+    if (!Number.isFinite(next))
+        return null;
+    const start = reminder.every_seconds
+        ? next - reminder.every_seconds * 1000
+        : Date.parse(reminder.last_fired_at ?? reminder.created_at ?? '');
+    if (!Number.isFinite(start) || next <= start)
+        return null;
+    return Math.min(1, Math.max(0, (now - start) / (next - start)));
+}
 /** The first line of the reminder text, for a one-line row title. */
 export function reminderTitle(reminder) {
     return reminder.name ?? reminder.prompt.split('\n')[0].trim();

package/dist/internal/stores/kortix-computer-store.d.ts

@@ -12,7 +12,7 @@ export interface ReadyChipState {
     primaryName?: string;
 }
 /** The panel surfaces reachable from outside the panel. */
-export type QuickView = 'terminal' | 'audit' | 'browser' | 'files';
+export type QuickView = 'terminal' | 'audit' | 'browser' | 'files' | 'reminders';
 /**
  * Extra aim for a quick-view request — "open the browser" vs "open the browser
  * ON THIS URL".

package/dist/internal/stores/session-hover-store.d.ts

@@ -11,6 +11,10 @@
  * the active row is what is left, and it is also the cheaper shape: exactly one
  * card is mounted at any time, by construction rather than by timing luck.
  *
+ * The store also holds the active row's element and the one card's content
+ * slot (`SessionBriefCardHost`): rows render their brief into that slot, and
+ * the host glides to the row instead of a new card appearing at it.
+ *
  * The delays live here rather than on the primitive for a performance reason.
  * If `openDelay` were a prop derived from `warm`, every row in the sidebar would
  * re-render each time the group warmed or cooled. Nothing selects `warm`, so it
@@ -20,15 +24,19 @@
 /** The first card costs a delay, so a pointer crossing the list on its way
  *  somewhere else does not flash open every row it passes over. */
 export declare const HOVER_OPEN_DELAY_MS = 200;
+/** While a card is open, a move to another row waits this long, and a newer
+ *  row restarts the wait: a pointer sweeping down the list moves the card once,
+ *  to where it stops, instead of re-rendering it for every row it crosses. */
+export declare const HOVER_MOVE_DEBOUNCE_MS = 50;
 /** Long enough for the pointer to cross the `sideOffset` gap into the card. */
 export declare const HOVER_CLOSE_DELAY_MS = 100;
 /** How long the group stays warm after its last card closes. */
 export declare const HOVER_WARM_GRACE_MS = 300;
 /**
- * Once one card is open the group is warm and the next row is instant, so the
- * card reads as moving to the row under the pointer instead of closing and
- * reopening. This is the rule the design system already states for tooltips:
- * delay before the first, none for the rest while the group is active.
+ * Once one card is open the group is warm and the next row costs only the move
+ * debounce, so the card reads as moving to the row under the pointer instead of
+ * closing and reopening. This is the rule the design system already states for
+ * tooltips: delay before the first, (almost) none for the rest.
  */
 export declare function hoverOpenDelayMs(warm: boolean): number;
 /**
@@ -38,9 +46,16 @@ export declare function hoverOpenDelayMs(warm: boolean): number;
 export declare function clearIfActive(current: string | null, sessionId: string): string | null;
 interface SessionHoverState {
     activeSessionId: string | null;
+    /** The active row's element: the card lines up with it. */
+    anchor: HTMLElement | null;
+    /** Keyboard focus moves the card without a glide. */
+    via: 'pointer' | 'focus';
+    /** The shared card's content slot, from `SessionBriefCardHost`. */
+    slot: HTMLElement | null;
+    setSlot: (slot: HTMLElement | null) => void;
     /** Deliberately unselected by any component — see the note above. */
     warm: boolean;
-    openSession: (sessionId: string) => void;
+    openSession: (sessionId: string, anchor?: HTMLElement, via?: 'pointer' | 'focus') => void;
     closeSession: (sessionId: string) => void;
     /** Immediate, for a click that opens something else and for unmount. */
     dismiss: () => void;