@elizaos/ui 2.0.3-beta.2 → 2.0.3-beta.3

package/components/chat/widgets/home-widget-card.js

@@ -0,0 +1,64 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * HomeWidgetCard — the compact, icon-first, whole-card-clickable building block
+ * for the home dashboard (#9143).
+ *
+ * Home widgets are glanceable, not dashboards: an icon, a one-word label, and a
+ * SINGLE high-priority datum (a value and/or a status badge). The whole card is
+ * a button — tapping it navigates to the full surface (or runs the relevant
+ * action). Because the visible text is intentionally minimal, the full meaning
+ * lives in `ariaLabel` for screen readers.
+ *
+ * Sits on the orange home wallpaper, so it's a translucent neutral glass tile
+ * (orange is accent-only; resting neutral → neutral-with-opacity hover, never
+ * orange→black — per the hover system).
+ */
+import { useMemo } from "react";
+import { reportUserViewSwitch } from "../../../chat/useSlashCommandController.js";
+import { cn } from "../../../lib/utils.js";
+import { useAppSelectorShallow } from "../../../state/index.js";
+/**
+ * Navigation for home widgets: tapping a card opens the relevant full surface.
+ * `openView` mirrors the home tile path (the `eliza:navigate:view` rail +
+ * proactive-decider report), `openTab` switches a builtin tab. Stable across
+ * renders so it never breaks a widget's memoization.
+ */
+export function useWidgetNavigation() {
+    const { setTab } = useAppSelectorShallow((s) => ({ setTab: s.setTab }));
+    return useMemo(() => ({
+        openView(path, viewId) {
+            if (typeof window !== "undefined") {
+                window.dispatchEvent(new CustomEvent("eliza:navigate:view", {
+                    detail: { viewPath: path },
+                }));
+            }
+            reportUserViewSwitch(viewId ?? path, path);
+        },
+        openTab(tab) {
+            setTab?.(tab);
+            reportUserViewSwitch(tab);
+        },
+    }), [setTab]);
+}
+// Default values sit on the orange home wallpaper; keep them high contrast.
+const TONE_VALUE_CLASS = {
+    default: "text-white",
+    danger: "text-danger",
+    warn: "text-warn",
+};
+const TONE_DOT_CLASS = {
+    default: "bg-muted",
+    danger: "bg-danger",
+    warn: "bg-warn",
+};
+export function HomeWidgetCard({ icon, label, value, meta, badge, tone = "default", testId, ariaLabel, onActivate, }) {
+    return (_jsxs("button", { type: "button", "data-testid": testId, "aria-label": ariaLabel, title: label, onClick: onActivate, className: cn(
+        // Dark neutral glass keeps white text and orange status values legible.
+        "group flex w-full items-center gap-3 rounded-xl border border-white/12 bg-black/45 px-3 py-2.5 text-left backdrop-blur-md", "transition-colors hover:bg-black/55"), children: [_jsxs("span", { className: cn("relative inline-flex h-8 w-8 shrink-0 items-center justify-center rounded-lg bg-white/10 text-white/85 [&>svg]:h-4 [&>svg]:w-4", tone === "danger" && "text-danger", tone === "warn" && "text-warn"), children: [icon, tone !== "default" ? (_jsx("span", { "aria-hidden": true, className: cn(
+                        // Use a filled dot; the ring only separates it from the icon.
+                        "absolute -right-0.5 -top-0.5 h-2.5 w-2.5 rounded-full ring-2 ring-black/40", TONE_DOT_CLASS[tone]) })) : null] }), _jsx("span", { className: "flex min-w-0 flex-1 flex-col", children: value != null ? (_jsx("span", { className: cn("truncate text-sm font-semibold leading-tight", TONE_VALUE_CLASS[tone]), children: value })) : null }), meta != null ? (_jsx("span", { className: "shrink-0 text-2xs tabular-nums text-white/60", children: meta })) : null, badge != null ? (_jsx("span", { className: cn("shrink-0 rounded-full px-1.5 py-0.5 text-2xs font-semibold", tone === "danger"
+                    ? "bg-danger/15 text-danger"
+                    : tone === "warn"
+                        ? "bg-warn/15 text-warn"
+                        : "bg-accent-subtle text-accent"), children: badge })) : null] }));
+}

package/components/chat/widgets/inbox-unread.d.ts

@@ -0,0 +1,10 @@
+import type { WidgetProps } from "../../../widgets/types.js";
+export declare function InboxUnreadWidget(_props: Partial<WidgetProps>): import("react/jsx-runtime").JSX.Element | null;
+export declare const INBOX_HOME_WIDGET: {
+    readonly pluginId: "inbox";
+    readonly id: "inbox.unread";
+    readonly order: 85;
+    readonly signalKinds: readonly ["message", "approval"];
+    readonly Component: typeof InboxUnreadWidget;
+};
+//# sourceMappingURL=inbox-unread.d.ts.map

package/components/chat/widgets/inbox-unread.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbox-unread.d.ts","sourceRoot":"","sources":["../../../../../../../src/components/chat/widgets/inbox-unread.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AA2E1D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,CAAC,WAAW,CAAC,kDAqE7D;AAED,eAAO,MAAM,iBAAiB;;;;;;CAMpB,CAAC"}

package/components/chat/widgets/inbox-unread.js

@@ -0,0 +1,119 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Inbox } from "lucide-react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { client } from "../../../api/index.js";
+import { useIntervalWhenDocumentVisible } from "../../../hooks/index.js";
+import { usePublishHomeAttention } from "../../../widgets/home-attention-store.js";
+import { HOME_SIGNAL_WEIGHTS } from "../../../widgets/home-priority.js";
+import { HomeWidgetCard, useWidgetNavigation } from "./home-widget-card.js";
+// Compact, icon-first home card for the cross-channel inbox: the ONE unread
+// thread that most needs a reply. Same data source the full InboxView owns —
+// GET {base}/api/lifeops/inbox (served by the personal-assistant routes) —
+// parsed by the same wire shape (LifeOpsInboxMessage in
+// packages/shared/src/contracts/personal-assistant.ts). Renders null when
+// nothing is unread, and self-publishes a `message`-weight home signal while
+// unread threads exist so the card floats up over quiet widgets.
+const INBOX_WIDGET_KEY = "inbox/inbox.unread";
+const INBOX_REFRESH_INTERVAL_MS = 20_000; // matches InboxView's INBOX_POLL_MS
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+/**
+ * Extract unread threads from the `/api/lifeops/inbox` payload (untrusted
+ * network input, so narrowed defensively). The wire shape mirrors
+ * `LifeOpsInboxMessage`: `{ id, sender: { displayName }, subject, snippet,
+ * unread, priorityScore?, priorityCategory? }`. "urgent / needs-reply" maps to
+ * the scorer's `important` bucket (category === "important"); there is no
+ * literal `classification` on the wire.
+ */
+function parseUnread(payload) {
+    if (!isRecord(payload) || !Array.isArray(payload.messages))
+        return [];
+    const threads = [];
+    for (const message of payload.messages) {
+        if (!isRecord(message))
+            continue;
+        if (message.unread !== true)
+            continue;
+        const id = typeof message.id === "string" ? message.id : null;
+        if (!id)
+            continue;
+        const sender = isRecord(message.sender) && typeof message.sender.displayName === "string"
+            ? message.sender.displayName
+            : "Someone";
+        const subject = typeof message.subject === "string" ? message.subject : "";
+        const priorityScore = typeof message.priorityScore === "number" ? message.priorityScore : 0;
+        const important = message.priorityCategory === "important";
+        threads.push({ id, sender, subject, important, priorityScore });
+    }
+    return threads;
+}
+/**
+ * Shallow content equality so an unchanged 20s poll doesn't re-render — only the
+ * fields the card renders (count, top thread identity, importance) participate.
+ */
+function unreadEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    return a.every((thread, i) => {
+        const other = b[i];
+        return (thread.id === other.id &&
+            thread.sender === other.sender &&
+            thread.subject === other.subject &&
+            thread.important === other.important &&
+            thread.priorityScore === other.priorityScore);
+    });
+}
+export function InboxUnreadWidget(_props) {
+    const [unread, setUnread] = useState([]);
+    const [loaded, setLoaded] = useState(false);
+    const nav = useWidgetNavigation();
+    const loadInbox = useCallback(async () => {
+        try {
+            const response = await fetch(`${client.getBaseUrl()}/api/lifeops/inbox`);
+            if (!response.ok)
+                return;
+            const next = parseUnread(await response.json());
+            // Skip the state update (and the re-render) when the poll is unchanged.
+            setUnread((prev) => (unreadEqual(prev, next) ? prev : next));
+        }
+        catch {
+            // Best-effort: keep the last good data on a transient fetch failure.
+        }
+        finally {
+            setLoaded(true);
+        }
+    }, []);
+    useEffect(() => {
+        void loadInbox();
+    }, [loadInbox]);
+    useIntervalWhenDocumentVisible(() => void loadInbox(), INBOX_REFRESH_INTERVAL_MS);
+    // Unread threads need a reply — float the card up at `message` weight while
+    // any exist; clear otherwise.
+    usePublishHomeAttention(INBOX_WIDGET_KEY, unread.length > 0 ? HOME_SIGNAL_WEIGHTS.message : null);
+    // The single high-priority datum: the highest-scored unread thread. Computed
+    // once per snapshot change so an unchanged poll keeps a stable reference.
+    const top = useMemo(() => {
+        if (unread.length === 0)
+            return null;
+        return unread.reduce((best, thread) => thread.priorityScore > best.priorityScore ? thread : best);
+    }, [unread]);
+    const hasImportant = useMemo(() => unread.some((thread) => thread.important), [unread]);
+    // Render nothing until the first load resolves with unread threads — the home
+    // surface must not show an empty placeholder (#9143).
+    if (!loaded || top == null)
+        return null;
+    // One datum, icon-first: the top thread's sender (or its subject when the
+    // sender is unknown); the unread count is a badge; warn tone when any unread
+    // thread is in the scorer's "important" bucket. Tapping opens the Inbox view.
+    const datum = top.sender !== "Someone" ? top.sender : top.subject || top.sender;
+    const tone = hasImportant ? "warn" : "default";
+    return (_jsx(HomeWidgetCard, { icon: _jsx(Inbox, {}), label: "Inbox", value: datum, badge: unread.length, tone: tone, testId: "chat-widget-inbox-unread", ariaLabel: `Inbox: ${unread.length} unread thread${unread.length === 1 ? "" : "s"} need a reply, top from ${datum}. Open Inbox.`, onActivate: () => nav.openView("/inbox", "inbox") }));
+}
+export const INBOX_HOME_WIDGET = {
+    pluginId: "inbox",
+    id: "inbox.unread",
+    order: 85,
+    signalKinds: ["message", "approval"],
+    Component: InboxUnreadWidget,
+};

package/components/chat/widgets/inline-registry.d.ts

@@ -19,7 +19,7 @@
  * process-global keyed by `kind`; re-registering a `kind` replaces it.
  */
 import type { ReactNode } from "react";
-import type { FormResultValue } from "./form-request";
+import type { FormResultValue } from "./form-request.js";
 /**
  * Chat-surface handlers an inline widget may call. Carried per render; widgets
  * that need none simply ignore the fields.

package/components/chat/widgets/messages.d.ts

@@ -0,0 +1,8 @@
+import type { WidgetProps } from "../../../widgets/types.js";
+/**
+ * Frontpage Messages widget (#9143). The shared "messages" default widget:
+ * recent conversations (title + relative time), so the home surfaces quick
+ * access to recent chats. Reads the app store's conversation list directly.
+ */
+export declare function MessagesWidget(props: WidgetProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=messages.d.ts.map

package/components/chat/widgets/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../../../../../src/components/chat/widgets/messages.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAU1D;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,kDA6DhD"}

package/components/chat/widgets/messages.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { MessageSquare } from "lucide-react";
+import { useMemo } from "react";
+import { useAppSelector } from "../../../state/index.js";
+import { formatRelativeTime } from "../../../utils/format.js";
+import { HomeWidgetCard, useWidgetNavigation } from "./home-widget-card.js";
+import { WidgetSection } from "./shared.js";
+const MAX_HOME_CONVERSATIONS = 4;
+function byUpdatedDesc(a, b) {
+    return (b.updatedAt ?? "").localeCompare(a.updatedAt ?? "");
+}
+/**
+ * Frontpage Messages widget (#9143). The shared "messages" default widget:
+ * recent conversations (title + relative time), so the home surfaces quick
+ * access to recent chats. Reads the app store's conversation list directly.
+ */
+export function MessagesWidget(props) {
+    const conversations = useAppSelector((s) => s.conversations);
+    const nav = useWidgetNavigation();
+    const recent = useMemo(() => (Array.isArray(conversations) ? [...conversations] : [])
+        .sort(byUpdatedDesc)
+        .slice(0, MAX_HOME_CONVERSATIONS), [conversations]);
+    // Render nothing until there are conversations. The always-visible home
+    // surface (#9143) must not show an empty placeholder card — empty-state hints
+    // belong on the dedicated view, not the home slot.
+    if (recent.length === 0) {
+        return null;
+    }
+    // Home slot: a single compact, icon-first, whole-card-clickable tile — the
+    // most-recent conversation's title as the one datum, total count as the
+    // badge. Tapping opens the Messages view. The sidebar keeps the full list.
+    if (props.slot === "home") {
+        const top = recent[0];
+        const title = top.title || "Untitled";
+        return (_jsx(HomeWidgetCard, { icon: _jsx(MessageSquare, {}), label: "Messages", value: title, meta: formatRelativeTime(top.updatedAt), badge: recent.length > 1 ? recent.length : undefined, testId: "widget-messages", ariaLabel: `Messages: ${recent.length} recent, latest ${title}. Open Messages.`, onActivate: () => nav.openView("/messages", "messages") }));
+    }
+    return (_jsx(WidgetSection, { title: "Messages", icon: _jsx(MessageSquare, {}), testId: "widget-messages", children: _jsx("ul", { className: "flex flex-col gap-0.5", children: recent.map((c) => (_jsxs("li", { className: "flex items-center justify-between gap-2 px-1 py-1", children: [_jsx("span", { className: "truncate text-xs font-medium text-txt", children: c.title || "Untitled" }), _jsx("span", { className: "shrink-0 text-3xs text-muted", children: formatRelativeTime(c.updatedAt) })] }, c.id))) }) }));
+}

package/components/chat/widgets/music-player.d.ts

@@ -1,3 +1,3 @@
-import type { ChatSidebarWidgetProps } from "./types";
+import type { ChatSidebarWidgetProps } from "./types.js";
 export declare function MusicPlayerSidebarWidget(_props: ChatSidebarWidgetProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=music-player.d.ts.map

package/components/chat/widgets/music-player.helpers.d.ts

@@ -1,3 +1,3 @@
-import type { ChatSidebarWidgetDefinition } from "./types";
+import type { ChatSidebarWidgetDefinition } from "./types.js";
 export declare const MUSIC_PLAYER_WIDGET: ChatSidebarWidgetDefinition;
 //# sourceMappingURL=music-player.helpers.d.ts.map

package/components/chat/widgets/needs-attention.d.ts

@@ -0,0 +1,22 @@
+import type { PendingUserAction } from "@elizaos/core";
+import type { WidgetProps } from "../../../widgets/types.js";
+/** A pending decision older than this escalates above the standard approval rank. */
+export declare const STALE_PENDING_AGE_MS: number;
+/**
+ * Poll the canonical pending-actions surface. Returns the live list plus a
+ * `loaded` flag so the widget can stay invisible until the first fetch resolves
+ * (the home surface must not flash an empty placeholder).
+ */
+export declare function useApprovals(): {
+    pending: PendingUserAction[];
+    loaded: boolean;
+};
+export declare function NeedsAttentionWidget(_props: Partial<WidgetProps>): import("react/jsx-runtime").JSX.Element | null;
+export declare const NEEDS_ATTENTION_HOME_WIDGET: {
+    readonly pluginId: "needs-attention";
+    readonly id: "needs-attention.pending";
+    readonly order: 60;
+    readonly signalKinds: readonly ["approval", "escalation"];
+    readonly Component: typeof NeedsAttentionWidget;
+};
+//# sourceMappingURL=needs-attention.d.ts.map

package/components/chat/widgets/needs-attention.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"needs-attention.d.ts","sourceRoot":"","sources":["../../../../../../../src/components/chat/widgets/needs-attention.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAQvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAgB1D,qFAAqF;AACrF,eAAO,MAAM,oBAAoB,QAAc,CAAC;AAkBhD;;;;GAIG;AACH,wBAAgB,YAAY,IAAI;IAC9B,OAAO,EAAE,iBAAiB,EAAE,CAAC;IAC7B,MAAM,EAAE,OAAO,CAAC;CACjB,CAqBA;AAgBD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,CAAC,WAAW,CAAC,kDA4ChE;AAED,eAAO,MAAM,2BAA2B;;;;;;CAM9B,CAAC"}

package/components/chat/widgets/needs-attention.js

@@ -0,0 +1,109 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CircleHelp } from "lucide-react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { client } from "../../../api/index.js";
+import { dispatchChatPrefill } from "../../../events/index.js";
+import { useIntervalWhenDocumentVisible } from "../../../hooks/index.js";
+import { usePublishHomeAttention } from "../../../widgets/home-attention-store.js";
+import { HOME_SIGNAL_WEIGHTS } from "../../../widgets/home-priority.js";
+import { HomeWidgetCard } from "./home-widget-card.js";
+// The canonical "actions requiring your response" home card (#9449 PILLAR C):
+// the ONE oldest decision the agent is blocked waiting on you for, with a badge
+// of how many are pending. Data source is GET /api/approvals (served by the
+// agent's approval-routes), which already projects the ApprovalService tasks
+// into PendingUserAction[] — so this card only renders, no business logic.
+//
+// Renders null when nothing is pending, and self-publishes a home-attention
+// signal so it floats up: `approval` weight while pending items exist, escalated
+// to `escalation` weight once the oldest one has been waiting longer than the
+// stale threshold (a decision left unanswered is more urgent over time).
+const NEEDS_ATTENTION_WIDGET_KEY = "needs-attention/needs-attention.pending";
+const REFRESH_INTERVAL_MS = 20_000;
+/** A pending decision older than this escalates above the standard approval rank. */
+export const STALE_PENDING_AGE_MS = 30 * 60_000; // 30 min
+/** Shallow content equality so an unchanged poll doesn't re-render. */
+function pendingEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    return a.every((item, i) => {
+        const other = b[i];
+        return (item.id === other.id &&
+            item.title === other.title &&
+            item.createdAt === other.createdAt);
+    });
+}
+/**
+ * Poll the canonical pending-actions surface. Returns the live list plus a
+ * `loaded` flag so the widget can stay invisible until the first fetch resolves
+ * (the home surface must not flash an empty placeholder).
+ */
+export function useApprovals() {
+    const [pending, setPending] = useState([]);
+    const [loaded, setLoaded] = useState(false);
+    const load = useCallback(async () => {
+        try {
+            const { pending: next } = await client.listPendingActions();
+            setPending((prev) => (pendingEqual(prev, next) ? prev : next));
+        }
+        catch {
+            // Best-effort: keep the last good data on a transient fetch failure.
+        }
+        finally {
+            setLoaded(true);
+        }
+    }, []);
+    useEffect(() => {
+        void load();
+    }, [load]);
+    useIntervalWhenDocumentVisible(() => void load(), REFRESH_INTERVAL_MS);
+    return { pending, loaded };
+}
+/**
+ * The single high-priority datum: the OLDEST pending action (waiting longest =
+ * most overdue). Computed once per snapshot so an unchanged poll keeps a stable
+ * reference.
+ */
+function oldestPending(pending) {
+    if (pending.length === 0)
+        return null;
+    return pending.reduce((oldest, item) => item.createdAt < oldest.createdAt ? item : oldest);
+}
+export function NeedsAttentionWidget(_props) {
+    const { pending, loaded } = useApprovals();
+    const top = useMemo(() => oldestPending(pending), [pending]);
+    // Float up at `approval` weight while anything is pending; escalate to
+    // `escalation` weight once the oldest decision has been waiting past the stale
+    // threshold (age is read at render — the home ranker stamps `now`, so the
+    // store holds the steady-state weight, not a clock value).
+    const weight = useMemo(() => {
+        if (top == null)
+            return null;
+        const stale = Date.now() - top.createdAt >= STALE_PENDING_AGE_MS;
+        return stale
+            ? HOME_SIGNAL_WEIGHTS.escalation
+            : HOME_SIGNAL_WEIGHTS.approval;
+    }, [top]);
+    usePublishHomeAttention(NEEDS_ATTENTION_WIDGET_KEY, weight);
+    // Route back to the handler: prefill the chat composer with a natural-language
+    // approval so the agent's RESOLVE_REQUEST action resolves it in the same room
+    // the request lives in. The widget never resolves the decision itself — it
+    // hands the user to the canonical action.
+    const onActivate = useCallback(() => {
+        if (top == null)
+            return;
+        dispatchChatPrefill({ text: `Approve: ${top.title}`, select: true });
+    }, [top]);
+    // Render nothing until the first load resolves with pending items (#9143).
+    if (!loaded || top == null)
+        return null;
+    const count = pending.length;
+    const stale = Date.now() - top.createdAt >= STALE_PENDING_AGE_MS;
+    return (_jsx(HomeWidgetCard, { icon: _jsx(CircleHelp, {}), label: "Needs response", value: top.title, badge: count, tone: stale ? "warn" : "default", testId: "chat-widget-needs-attention", ariaLabel: `${count} action${count === 1 ? "" : "s"} need your response, oldest: ${top.title}. Respond in chat.`, onActivate: onActivate }));
+}
+export const NEEDS_ATTENTION_HOME_WIDGET = {
+    pluginId: "needs-attention",
+    id: "needs-attention.pending",
+    order: 60,
+    signalKinds: ["approval", "escalation"],
+    Component: NeedsAttentionWidget,
+};

package/components/chat/widgets/notifications.d.ts

@@ -0,0 +1,9 @@
+import type { WidgetProps } from "../../../widgets/types.js";
+/**
+ * Frontpage Notifications widget (#9143). A "default" home-slot widget showing
+ * the most recent agent notifications, so the Springboard home surfaces real
+ * activity out of the box rather than only launcher icons. Reads the shared
+ * notification store directly (no per-widget polling).
+ */
+export declare function NotificationsWidget(props: WidgetProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=notifications.d.ts.map

package/components/chat/widgets/notifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notifications.d.ts","sourceRoot":"","sources":["../../../../../../../src/components/chat/widgets/notifications.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAyB1D;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,WAAW,kDA4DrD"}

package/components/chat/widgets/notifications.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Bell } from "lucide-react";
+import { useNotifications } from "../../../state/notifications/notification-store.js";
+import { rankHomeNotifications } from "../../../widgets/home-priority.js";
+import { HomeWidgetCard, useWidgetNavigation } from "./home-widget-card.js";
+import { WidgetSection } from "./shared.js";
+const MAX_HOME_NOTIFICATIONS = 4;
+function NotificationRow({ notification, }) {
+    return (_jsxs("li", { className: "flex flex-col gap-0.5 px-1 py-1", children: [_jsx("span", { className: "truncate text-xs font-medium text-txt", children: notification.title }), notification.body ? (_jsx("span", { className: "truncate text-2xs text-muted", children: notification.body })) : null] }));
+}
+/**
+ * Frontpage Notifications widget (#9143). A "default" home-slot widget showing
+ * the most recent agent notifications, so the Springboard home surfaces real
+ * activity out of the box rather than only launcher icons. Reads the shared
+ * notification store directly (no per-widget polling).
+ */
+export function NotificationsWidget(props) {
+    const { notifications, unreadCount } = useNotifications();
+    const nav = useWidgetNavigation();
+    // Rank by attention (unread → priority → recency) so an urgent notification
+    // surfaces ahead of a newer low-priority one, not merely the newest few.
+    const ranked = rankHomeNotifications(notifications);
+    const recent = ranked.slice(0, MAX_HOME_NOTIFICATIONS);
+    // Render nothing until there's real activity. The always-visible home surface
+    // (#9143) must not show an empty placeholder card — empty-state hints belong
+    // on the dedicated view, not the home slot.
+    if (recent.length === 0) {
+        return null;
+    }
+    // Home slot: a single compact, icon-first, whole-card-clickable tile —
+    // the top (highest-priority, unread-first) notification as the one datum,
+    // unread count as the badge, urgent → danger. Tapping opens the notification's
+    // own deep link if it has one, else the inbox. The sidebar keeps the list.
+    if (props.slot === "home") {
+        const top = recent[0];
+        const urgent = top.priority === "urgent";
+        return (_jsx(HomeWidgetCard, { icon: _jsx(Bell, {}), label: "Notifications", value: top.title, badge: unreadCount > 0 ? unreadCount : undefined, tone: urgent ? "danger" : top.priority === "high" ? "warn" : "default", testId: "widget-notifications", ariaLabel: `Notifications: ${unreadCount} unread, latest ${top.title}. Open inbox.`, onActivate: () => top.deepLink
+                ? nav.openView(top.deepLink, "inbox")
+                : nav.openView("/inbox", "inbox") }));
+    }
+    return (_jsx(WidgetSection, { title: "Notifications", icon: _jsx(Bell, {}), testId: "widget-notifications", action: unreadCount > 0 ? (_jsx("span", { className: "rounded-full bg-accent-subtle px-1.5 text-2xs font-medium text-accent", children: unreadCount })) : undefined, children: _jsx("ul", { className: "flex flex-col gap-0.5", children: recent.map((n) => (_jsx(NotificationRow, { notification: n }, n.id))) }) }));
+}

package/components/chat/widgets/orchestrator-grilling-card.d.ts

@@ -0,0 +1,24 @@
+/**
+ * OrchestratorGrillingCard — shows the orchestrator "grilling" a sub-agent's
+ * evidence against the acceptance criteria for a goal: a header with the
+ * overall verdict and a per-criterion list (state icon + label + optional
+ * note). Presentational only — the caller supplies the already-evaluated
+ * `status` and per-criterion `state`; the card never decides pass/fail itself.
+ * Follows the agent-orchestrator widget's tone vocabulary (accent = met,
+ * danger = failed, muted = pending).
+ */
+export type GrillingStatus = "evidence-pending" | "criteria-failed" | "criteria-met";
+export type GrillingCriterionState = "pending" | "failed" | "met";
+export type GrillingCriterion = {
+    id: string;
+    label: string;
+    state: GrillingCriterionState;
+    note?: string;
+};
+export type OrchestratorGrillingCardProps = {
+    status: GrillingStatus;
+    goal: string;
+    criteria: GrillingCriterion[];
+};
+export declare function OrchestratorGrillingCard({ status, goal, criteria, }: OrchestratorGrillingCardProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=orchestrator-grilling-card.d.ts.map

package/components/chat/widgets/orchestrator-grilling-card.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-grilling-card.d.ts","sourceRoot":"","sources":["../../../../../../../src/components/chat/widgets/orchestrator-grilling-card.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,MAAM,MAAM,cAAc,GACtB,kBAAkB,GAClB,iBAAiB,GACjB,cAAc,CAAC;AAEnB,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,QAAQ,GAAG,KAAK,CAAC;AAElE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,sBAAsB,CAAC;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG;IAC1C,MAAM,EAAE,cAAc,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,iBAAiB,EAAE,CAAC;CAC/B,CAAC;AAqDF,wBAAgB,wBAAwB,CAAC,EACvC,MAAM,EACN,IAAI,EACJ,QAAQ,GACT,EAAE,6BAA6B,2CAsD/B"}

package/components/chat/widgets/orchestrator-grilling-card.js

@@ -0,0 +1,57 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * OrchestratorGrillingCard — shows the orchestrator "grilling" a sub-agent's
+ * evidence against the acceptance criteria for a goal: a header with the
+ * overall verdict and a per-criterion list (state icon + label + optional
+ * note). Presentational only — the caller supplies the already-evaluated
+ * `status` and per-criterion `state`; the card never decides pass/fail itself.
+ * Follows the agent-orchestrator widget's tone vocabulary (accent = met,
+ * danger = failed, muted = pending).
+ */
+import { CheckCircle2, CircleDashed, Loader2, XCircle } from "lucide-react";
+function statusStyle(status) {
+    switch (status) {
+        case "criteria-met":
+            return {
+                label: "Criteria met",
+                toneClass: "bg-accent/20 text-accent",
+                icon: _jsx(CheckCircle2, { className: "h-3.5 w-3.5", "aria-hidden": true }),
+            };
+        case "criteria-failed":
+            return {
+                label: "Criteria failed",
+                toneClass: "bg-danger/20 text-danger",
+                icon: _jsx(XCircle, { className: "h-3.5 w-3.5", "aria-hidden": true }),
+            };
+        default:
+            return {
+                label: "Reviewing evidence",
+                toneClass: "bg-muted/20 text-muted",
+                icon: _jsx(Loader2, { className: "h-3.5 w-3.5 animate-spin", "aria-hidden": true }),
+            };
+    }
+}
+function criterionIcon(state) {
+    switch (state) {
+        case "met":
+            return _jsx(CheckCircle2, { className: "h-4 w-4 text-accent", "aria-hidden": true });
+        case "failed":
+            return _jsx(XCircle, { className: "h-4 w-4 text-danger", "aria-hidden": true });
+        default:
+            return _jsx(CircleDashed, { className: "h-4 w-4 text-muted", "aria-hidden": true });
+    }
+}
+function criterionStateLabel(state) {
+    switch (state) {
+        case "met":
+            return "met";
+        case "failed":
+            return "failed";
+        default:
+            return "pending";
+    }
+}
+export function OrchestratorGrillingCard({ status, goal, criteria, }) {
+    const style = statusStyle(status);
+    return (_jsxs("div", { "data-testid": "orchestrator-grilling", "data-grilling-status": status, className: "my-2 rounded-sm border border-border/50 bg-bg-accent/30 p-2 text-sm", children: [_jsxs("div", { className: "flex items-start justify-between gap-2", children: [_jsxs("div", { className: "min-w-0", children: [_jsx("div", { className: "text-3xs uppercase tracking-wider text-muted", children: "Validating evidence" }), _jsx("div", { className: "mt-0.5 font-semibold leading-snug", children: goal })] }), _jsxs("span", { "data-testid": "orchestrator-grilling-status", className: `inline-flex shrink-0 items-center gap-1 rounded-sm px-1.5 py-0.5 text-3xs font-medium ${style.toneClass}`, children: [style.icon, style.label] })] }), _jsx("ul", { className: "mt-2 flex flex-col gap-1.5", children: criteria.map((criterion) => (_jsxs("li", { "data-testid": `grilling-criterion-${criterion.id}`, "data-criterion-state": criterion.state, className: "flex items-start gap-2", children: [_jsx("span", { className: "mt-0.5 shrink-0", children: criterionIcon(criterion.state) }), _jsxs("div", { className: "min-w-0 flex-1", children: [_jsxs("div", { className: "flex items-center gap-2", children: [_jsx("span", { className: "min-w-0 flex-1 leading-snug", children: criterion.label }), _jsx("span", { className: "shrink-0 text-3xs uppercase tracking-wider text-muted", children: criterionStateLabel(criterion.state) })] }), criterion.note ? (_jsx("p", { className: "mt-0.5 text-3xs text-muted", children: criterion.note })) : null] })] }, criterion.id))) })] }));
+}

package/components/chat/widgets/relationships-attention.d.ts

@@ -0,0 +1,18 @@
+import type { WidgetProps } from "../../../widgets/types.js";
+/**
+ * RELATIONSHIPS "People" home widget (#9143). Glanceable, icon-first summary of
+ * the single highest-priority relationship signal: a pending merge that needs
+ * the user to confirm (approval), otherwise the stalest contact to reach out
+ * to. Reads the same relationships routes the full view uses
+ * (client.getRelationshipsPeople / getRelationshipsCandidates), polling quietly
+ * while the document is visible. Tapping the card opens the Relationships view.
+ */
+export declare function RelationshipsAttentionWidget({ slot }: Partial<WidgetProps>): import("react/jsx-runtime").JSX.Element | null;
+export declare const RELATIONSHIPS_HOME_WIDGET: {
+    readonly pluginId: "relationships";
+    readonly id: "relationships.attention";
+    readonly order: 90;
+    readonly signalKinds: readonly ["nudge", "approval"];
+    readonly Component: typeof RelationshipsAttentionWidget;
+};
+//# sourceMappingURL=relationships-attention.d.ts.map

package/components/chat/widgets/relationships-attention.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationships-attention.d.ts","sourceRoot":"","sources":["../../../../../../../src/components/chat/widgets/relationships-attention.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAmG1D;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,EAAE,IAAI,EAAE,EAAE,OAAO,CAAC,WAAW,CAAC,kDA6E1E;AAED,eAAO,MAAM,yBAAyB;;;;;;CAM5B,CAAC"}