@copilotkit/web-inspector 1.68.3 → 1.69.1

package/dist/index.d.mts

@@ -1,5 +1,7 @@
+import { MenuKey } from "./lib/inspector-nav.mjs";
 import { Anchor } from "./lib/types.mjs";
 import { InspectorOpenSource } from "./lib/telemetry.mjs";
+import { ActivitySnippetMessage, ChatSnippetCapture, EventSnippet, compileChatSnippet, compileFromActivityMessage, upsertEventSnippet } from "./lib/event-snippets.mjs";
 import * as lit from "lit";
 import { LitElement, TemplateResult } from "lit";
 import { CopilotKitCore, Memory, ɵThread } from "@copilotkit/core";
@@ -8,7 +10,9 @@ import { CopilotKitCore, Memory, ɵThread } from "@copilotkit/core";
 type InspectorOpenOptions = {
   /** Select the thread that contains the message. */threadId?: string; /** Narrow the Threads view to the agent that owns the thread. */
   agentId?: string; /** Scroll the selected thread timeline to this message when available. */
-  messageId?: string;
+  messageId?: string; /** Open this Inspect leaf instead of Threads. */
+  menu?: MenuKey; /** Select this Event Snippet after open. */
+  snippetId?: string;
 };
 declare const WEB_INSPECTOR_TAG: "cpk-web-inspector";
 declare const THREAD_INSPECTOR_TAG: "cpk-thread-inspector";
@@ -116,6 +120,12 @@ declare class CpkThreadInspector extends PortableLitElement {
     liveMessageVersion: {
       attribute: boolean;
     };
+    viewInAppMode: {
+      attribute: boolean;
+    };
+    viewInAppError: {
+      attribute: boolean;
+    };
     focusMessageId: {
       attribute: boolean;
     };
@@ -201,6 +211,8 @@ declare class CpkThreadInspector extends PortableLitElement {
    * so the conversation view reflects live streaming output.
    */
   liveMessageVersion: number;
+  viewInAppMode: "hidden" | "view" | "stop";
+  viewInAppError: string | null;
   focusMessageId: string | null;
   focusRequestId: number;
   private _tab;
@@ -364,6 +376,7 @@ declare class CpkThreadInspector extends PortableLitElement {
   private onDetailDividerUp;
   render(): TemplateResult<1>;
   private renderMetadataStrip;
+  private renderViewInAppAction;
   private renderActiveBulkControls;
   private renderRawEventBulkControls;
   private revealSourceEvent;
@@ -457,15 +470,50 @@ declare class WebInspectorElement extends LitElement {
   private isDragging;
   private pointerContext;
   private isOpen;
+  private accountCtaMotionPaused;
   private draggedDuringInteraction;
   private ignoreNextButtonClick;
   private selectedMenu;
   private pendingPersistedMenu;
+  private hasOpenedInspector;
+  private sidebarCollapsed;
+  private sidebarRailTooltip;
+  private colorScheme;
+  private hasExplicitColorScheme;
+  private systemColorSchemeMediaQuery;
+  private briefingRestoreMenu;
+  private homeViewedThisOpen;
   private hasResolvedCore;
   private settingsOpen;
   private readonly lastSelectedMenuByGroup;
   private lastScrolledAgentNavigationLayout;
+  private eventSnippets;
+  private selectedSnippetId;
+  private snippetRecipe;
+  private snippetName;
+  private snippetJson;
+  private snippetToolName;
+  private snippetToolArgs;
+  private snippetReasoningText;
+  private snippetTextContent;
+  private snippetActivityType;
+  private snippetActivityContent;
+  private snippetError;
+  private snippetBanner;
+  private snippetConfirmOpen;
+  private lastInject;
+  private snippetListWidth;
+  private snippetDividerResizing;
+  private snippetDividerPointerId;
+  private snippetDividerStartX;
+  private snippetDividerStartWidth;
   private selectedThreadId;
+  private inAppThreadId;
+  private inAppAgentId;
+  private inAppSource;
+  private activeViewInAppRequestId;
+  private viewInAppError;
+  private inspectorBridgeUnsubscribers;
   private selectedRealThreadIsExplicit;
   private selectedLocalExampleThreadId;
   private requestedThreadId;
@@ -479,16 +527,32 @@ declare class WebInspectorElement extends LitElement {
   private _threads;
   private _threadStoreSubscriptions;
   private _threadsByAgent;
+  private threadUsageSignature;
+  private threadUsageRefreshTimer;
   private _threadsErrorByAgent;
   private _threadsLoadingByAgent;
   private _ownedThreadStores;
+  private playgroundAgent;
+  private playgroundAgentId;
+  private playgroundAgentUnsubscribe;
+  private playgroundMessages;
+  private playgroundInput;
+  private playgroundIsRunning;
+  private playgroundRunStartedAt;
+  private playgroundReasoningDurations;
+  private playgroundIsLoadingThread;
+  private playgroundError;
+  private playgroundSourceThreadId;
+  private playgroundShowEphemeralNotice;
   private threadCapabilityEnabled;
   private threadCapabilityGeneration;
   private contextMenuOpen;
+  private layoutMenuOpen;
   private dockMode;
   private popOut;
   private inspectorPortal;
   private previousBodyMargins;
+  private previousHtmlOverflowX;
   private transitionTimeoutId;
   private bodyTransitionTimeoutIds;
   private pendingSelectedContext;
@@ -502,14 +566,83 @@ declare class WebInspectorElement extends LitElement {
   private evtColWidths;
   private _evtColResize;
   private announcementHtml;
+  private announcementMarkdown;
   private announcementTimestamp;
   private announcementPreviewText;
   private announcementCtaLabel;
-  private hasUnseenAnnouncement;
   private announcementLoaded;
   private announcementPromise;
-  private showAnnouncementPreview;
-  private announcementExpanded;
+  private newsSignalArmed;
+  /** Which signal's beat is in flight, or null between beats. */
+  private pulsingSignal;
+  /**
+   * The single pending-beat slot. A beat that cannot land is deferred, never
+   * discarded — see `startSignalPulse` for the four reasons it cannot land.
+   */
+  private pendingPulseSignal;
+  private pulseTimeoutId;
+  /**
+   * Per-source latches for the error signal, fed from the subscriptions that
+   * already exist rather than from the event history: the event buffer is
+   * bounded per agent and in total and evicts entries, so counting events
+   * could silently lose a live failure.
+   */
+  private readonly errorSignalArmed;
+  /** Unread app errors. Cleared when the landing view is read. */
+  private readonly eventErrorArmed;
+  /** Latest detail for each event source, retained after that source is read. */
+  private readonly eventErrorDetails;
+  private pendingScrollToEventId;
+  private pendingScrollToToolCallId;
+  /** Last time an inspector-owned /threads refresh left this host, per agent. */
+  private readonly threadRefreshLastSentAt;
+  /** Trailing /threads refresh timers, one per agent. */
+  private readonly threadRefreshTrailingTimers;
+  /**
+   * Whether this outage has already had its beat. Global rather than
+   * per-source: a connection failure cascades into thread failures, so one
+   * root cause must not produce two nudges. Reset when nothing is red, which
+   * is what makes a resolved-then-recurring failure beat again.
+   */
+  private errorBeatSpent;
+  /** Per-outage dedup for `oss.inspector.error_signal_viewed`. */
+  private readonly errorSignalViewedSources;
+  /**
+   * The signal whose gesture is running its tail — the pill on screen and the
+   * sentence in the live region, both of which outlive the beat.
+   *
+   * Together with `pulsingSignal` this IS the single pending-beat slot, not a
+   * second scheduling concept: `startSignalPulse` defers while either is set,
+   * so the third deferral reason simply covers a longer beat. Null for the
+   * announcement, which has no tail and therefore behaves exactly as before.
+   */
+  private gestureSignal;
+  /** Where the running gesture's pill is, or null when it has none. */
+  private pillPhase;
+  /**
+   * Which side the pill opens from, or null before the room has been measured.
+   * Decided once, at gesture start, and never revisited mid-gesture.
+   */
+  private pillDirection;
+  private pillTimeoutId;
+  /** Hover/focus menu on the closed launcher. */
+  private launcherHudOpen;
+  private launcherHudSide;
+  private launcherHudHelp;
+  private launcherHudCloseTimer;
+  /**
+   * Leaf a HUD row asked for. Consumed by `openInspector` so a red dot on
+   * the circle cannot steal "Turn on Threads". Not a public open option.
+   */
+  private hudLandingMenu;
+  /**
+   * Whether this outage's pill actually opened. Per outage rather than per
+   * phase, so a second source arming behind the first reports the same answer
+   * the reader actually got. Reset with `errorBeatSpent`.
+   */
+  private pillOutcome;
+  private viewedNewsSignalIds;
+  private pendingNewsSignalViewed;
   private viewedBannerSurfaces;
   private pendingBannerViewed;
   private clickedBannerIds;
@@ -543,20 +676,18 @@ declare class WebInspectorElement extends LitElement {
   private resizePointerId;
   private resizeStart;
   private resizeInitialSize;
+  private resizeInitialPosition;
+  private resizeEdge;
   private isResizing;
   private readonly customTabIcons;
   private get menuItems();
-  /** Return the primary navigation group that owns a legacy leaf key. */
-  private getGroupForMenu;
-  /** Return the primary group for the current legacy leaf selection. */
-  private get selectedGroup();
-  /** Return only currently visible legacy leaves owned by a group. */
+  /** Return only currently visible leaves owned by a group. */
   private getVisibleMenuItemsForGroup;
   /** Resolve a group's last visible leaf, falling back to its first leaf. */
   private getMenuForGroup;
   /** Replace a leaf that became hidden with its group's first visible leaf. */
   private reconcileSelectedMenuVisibility;
-  /** Open a primary group at its last currently visible legacy leaf. */
+  /** Open a sidebar group at its last currently visible leaf. */
   private handleGroupSelect;
   /** Toggle Settings without replacing or persisting the active legacy leaf. */
   private handleSettingsToggle;
@@ -587,10 +718,15 @@ declare class WebInspectorElement extends LitElement {
   /** Selects the onboarding path for an enabled runtime with no saved Threads. */
   private getThreadsEmptyOnboardingAction;
   private subscribeToThreadStore;
+  private rebuildFlattenedThreads;
+  private scheduleInspectorUsageRefresh;
+  private clearInspectorUsageRefresh;
   private autoSelectLatestThread;
   private teardownThreadStoreSubscriptions;
   private ensureOwnedThreadStore;
   private refreshOwnedThreadStore;
+  private sendOwnedThreadRefresh;
+  private cancelThreadRefreshDebounce;
   private updateOwnedThreadStoreHeaders;
   private removeOwnedThreadStore;
   private teardownOwnedThreadStores;
@@ -631,6 +767,7 @@ declare class WebInspectorElement extends LitElement {
   private updateContextOptions;
   private getEventsForSelectedContext;
   private focusThread;
+  private focusEventSnippets;
   private filterEvents;
   private getLatestStateForAgent;
   private getLatestMessagesForAgent;
@@ -649,19 +786,89 @@ declare class WebInspectorElement extends LitElement {
   static styles: lit.CSSResult[];
   connectedCallback(): void;
   private ensureBrandFonts;
+  private handleDocumentVisibilityChange;
   disconnectedCallback(): void;
   firstUpdated(): void;
   render(): TemplateResult<1>;
   protected willUpdate(): void;
   protected updated(): void;
   private renderButton;
+  /**
+   * The words the running gesture carries, or null when the launcher is quiet.
+   *
+   * Read from the signal's own description rather than from a condition on the
+   * tone, so a third signal can carry a pill by declaring a label.
+   */
+  private getGestureLabel;
+  /**
+   * The pill, laid out at its full width and clipped, for the whole gesture.
+   *
+   * It renders from the first frame of the beat — clipped to nothing, so it
+   * shows nothing — because the room it needs cannot be measured until it has
+   * been laid out, and the direction is decided at gesture start.
+   */
+  private renderLauncherPill;
+  /**
+   * A click on the pill opens the Inspector, exactly as pressing the mark
+   * does — reusing the launcher's own open source, so the telemetry catalogue
+   * is untouched and the two paths cannot be told apart downstream.
+   *
+   * Deliberately NOT focusable and deliberately not in the tab order: the
+   * launcher beside it is already a focusable control for this same action,
+   * and a second tab stop for one action is a regression. The pill stays
+   * `aria-hidden` and this handler is a pointer affordance only.
+   *
+   * The gesture ends with the open, because `openInspector` cancels the tail —
+   * the panel is over the launcher, so there is nothing left to reveal.
+   */
+  private handlePillClick;
+  private isLauncherHudBlocked;
+  private resolveLauncherHudSide;
+  private openLauncherHud;
+  private closeLauncherHud;
+  private handleLauncherHudEnter;
+  private handleLauncherHudLeave;
+  private handleLauncherHudFocusIn;
+  private handleLauncherHudFocusOut;
+  private handleLauncherHudKeydown;
+  private handleHudActionClick;
+  private handleHudHelpClick;
+  private handleHudRowClick;
+  private renderHudCheck;
+  private renderHudRow;
+  private renderLauncherHud;
   /** Render a trusted action with optional context-specific copy. */
   private renderInspectorAction;
-  private renderInspectorMetadataHeader;
+  private renderInspectorSidebar;
+  private renderSidebarIntelligenceStatus;
+  private handleSidebarToggle;
+  private handleSidebarRailTooltipShow;
+  private handleSidebarRailTooltipHide;
+  private handleColorSchemeToggle;
+  private getHomeModel;
+  private renderHomeView;
+  private renderHomeWhatsNewPreview;
+  private renderWhatsNewView;
+  private renderHomeIntelligenceHud;
+  private renderHomeSystemHealth;
+  private renderEventErrorBanner;
+  private handleEventErrorBannerKeydown;
+  /** Scroll the landing view to the failed tool call or RUN_ERROR again. */
+  private refocusEventErrorLanding;
+  private handleHomeLastEventSelect;
+  private renderHomeFeatures;
+  private handleHomeHeroCta;
+  private maybeTrackHomeViewed;
   private renderWindow;
   private hydrateStateFromStorageEarly;
   private hydrateStateFromStorage;
-  /** Restore a visible legacy leaf, or use Threads for stale state. */
+  /** Follow the OS preference until a person deliberately picks a theme. */
+  private hydrateColorSchemePreference;
+  private getSystemColorScheme;
+  private readonly handleSystemColorSchemeChange;
+  private subscribeToSystemColorScheme;
+  private unsubscribeFromSystemColorScheme;
+  /** Restore a visible leaf, or open Home for first install and stale state. */
   private restorePersistedMenu;
   /** Resolve a valid stored leaf after the first Core exposes its sources. */
   private resolvePendingPersistedMenu;
@@ -676,6 +883,7 @@ declare class WebInspectorElement extends LitElement {
   private get isPoppedOut();
   private get activeRoot();
   private getPopOutCssTexts;
+  private getRenderedInspectorWindowSize;
   private requestPopOut;
   private unbindPopOutPointerDown;
   private handlePopOutClosed;
@@ -709,7 +917,8 @@ declare class WebInspectorElement extends LitElement {
   openInspector(source: InspectorOpenSource, options?: InspectorOpenOptions): void;
   private closeInspector;
   private renderIcon;
-  private renderDockControls;
+  private renderWindowLayoutMenu;
+  private handleLayoutMenuToggle;
   private getDockedWindowStyles;
   private handleDockClick;
   private serializeAttributes;
@@ -729,7 +938,37 @@ declare class WebInspectorElement extends LitElement {
   private copiedContextItems;
   private renderCoreWarningBanner;
   private getCoreStatusSummary;
+  private resolvePlaygroundAgentId;
+  private teardownPlaygroundAgent;
+  private syncPlaygroundMessages;
+  private startPlaygroundSession;
+  private mapThreadMessagesToPlayground;
+  private handlePlaygroundThreadSourceChange;
+  private runPlaygroundAgent;
+  private sendPlaygroundMessage;
+  private handlePlaygroundSubmit;
+  private handlePlaygroundSuggestion;
+  private handlePlaygroundInput;
+  private handlePlaygroundKeyDown;
+  private handlePlaygroundRetry;
+  private handlePlaygroundStop;
+  private renderPlaygroundComposer;
+  private reloadEventSnippets;
+  private handleSnippetImportChange;
+  private renderSnippetImportControl;
+  private selectEventSnippet;
+  private compileSnippetDraft;
+  private getSnippetThreadId;
+  private getSnippetRunId;
+  private getSnippetTargetAgent;
+  private applyRecipeToEditor;
+  private handleSnippetRecipeChange;
+  private saveCurrentSnippet;
+  private runCurrentSnippet;
+  private resetLastSnippetRun;
+  private renderEventSnippetsView;
   private renderMainContent;
+  private renderPlaygroundView;
   private renderSettingsPanel;
   private trackOpened;
   private getVisibleInspectorMetadataAction;
@@ -740,11 +979,13 @@ declare class WebInspectorElement extends LitElement {
   private trackMetadataModuleIfChanged;
   private maybeTrackInspectorMetadataViews;
   private handleInspectorMetadataActionClick;
-  private trackBannerDismissedOnce;
-  private trackBannerClickedOnce;
+  private trackWhatsNewClickedOnce;
   private handleTalkToEngineerClick;
   private handleThreadsIntelligenceSignupClick;
   private handleThreadsTalkToEngineerClick;
+  private handleSnippetListDividerPointerDown;
+  private handleSnippetListDividerPointerMove;
+  private handleSnippetListDividerPointerUp;
   private handleThreadDividerPointerDown;
   private handleThreadDividerPointerMove;
   private handleThreadDividerPointerUp;
@@ -754,6 +995,12 @@ declare class WebInspectorElement extends LitElement {
   private getExampleThreadProvider;
   private trackThreadsExampleViewedOnce;
   private trackThreadsExampleSelectedOnce;
+  private subscribeToInspectorThreadBridge;
+  private unsubscribeFromInspectorThreadBridge;
+  private getViewInAppMode;
+  private handleViewInApp;
+  private handleStopViewing;
+  private getSelectedRealThread;
   private getCurrentExampleTourProps;
   private trackThreadsExampleTourStepViewedOnce;
   private syncExampleTourTab;
@@ -808,8 +1055,10 @@ declare class WebInspectorElement extends LitElement {
   /** Renders trusted Threads usage and its independent plan action. */
   private renderThreadsUsageFooter;
   private renderThreadsView;
+  private renderEventsToolbar;
   private renderEventsTable;
   private handleEventFilterInput;
+  private handleEventAgentChange;
   private handleEventTypeChange;
   private resetEventFilters;
   private _onEvtColResizeStart;
@@ -819,8 +1068,31 @@ declare class WebInspectorElement extends LitElement {
   private exportEvents;
   private renderAgentsView;
   private renderContextDropdown;
+  /**
+   * The Agent view is empty on "All Agents". Pick the agent that just failed
+   * a tool, or the one with the most recent activity.
+   */
+  private applyEventErrorLanding;
+  /**
+   * Whether the landing view really carries the item the card points at.
+   * Mirrors the two branches of `applyEventErrorLanding` that can bail out.
+   */
+  private hasEventErrorHighlight;
+  private findLatestRunErrorEvent;
+  private flushErrorLandingScroll;
+  /**
+   * The Agent view is empty on "All Agents". Pick the agent that just failed
+   * a tool, or the one with the most recent activity.
+   */
+  private focusAgentForView;
   private handleMenuSelect;
   private handleContextDropdownToggle;
+  /** Expand the icon-rail agent scope on hover while preserving keyboard access. */
+  private handleIconRailContextPointerEnter;
+  private handleIconRailContextPointerLeave;
+  private handleIconRailContextPointerDown;
+  private handleIconRailContextFocusIn;
+  private handleIconRailContextFocusOut;
   private handleContextOptionSelect;
   private renderCapabilitiesView;
   private renderCapabilityRow;
@@ -837,31 +1109,220 @@ declare class WebInspectorElement extends LitElement {
   private renderContextView;
   private renderContextCard;
   private getContextValuePreview;
+  private getToolsForAgent;
+  private renderAgentToolsSection;
   private formatContextValue;
   private copyContextValue;
   private toggleContextExpansion;
   private handleGlobalPointerDown;
   private toggleRowExpansion;
-  private renderAnnouncementBanner;
+  /** Whether a given subject currently has something to say. */
+  private isSignalArmed;
+  /**
+   * The signal that owns the single launcher dot, or null when the launcher is
+   * quiet. Precedence rather than replacement: a suppressed signal stays armed
+   * and takes the dot as soon as the higher-priority one clears, and its own
+   * navigation marker is visible the whole time.
+   */
+  private getActiveLauncherSignal;
+  /**
+   * The marker a navigation entry carries, or null for an unmarked entry.
+   *
+   * Markers are independent of the launcher's single dot, so a suppressed
+   * signal is never actually hidden once the panel is open. They also render
+   * on the entry that is *currently selected*: for the news signal that never
+   * mattered, because its marker clears as soon as the view renders, but a
+   * state mirror stays true while it is being read and suppressing it on the
+   * active entry would make it reappear on navigating away.
+   */
+  private getNavigationSignalFor;
+  /** Whether a wiring error source is currently red. */
+  private hasArmedErrorSignal;
+  private armEventErrorFromCode;
+  private armEventError;
+  private clearEventError;
+  private clearAllEventErrors;
+  /**
+   * An event error is unread until its landing view is actually on screen.
+   * Opening the Inspector for a different leaf must not burn it.
+   */
+  private maybeCompleteEventErrorView;
+  private isReducedMotionPreferred;
+  private armNewsSignal;
+  private clearNewsSignal;
+  /**
+   * Requests one beat for a signal, running it now or deferring it.
+   *
+   * There is a single pending slot and four reasons a beat cannot land. All
+   * four are the same situation — "cannot land now, run later" — and treating
+   * them alike is the point: three separate behaviours for one situation would
+   * not survive a third signal.
+   *
+   * Reason 3 is not cosmetic. Starting a beat while one runs does not restart
+   * the animation, because the attribute it binds to does not change value and
+   * the pseudo-element selectors match on attribute *presence*; the running
+   * beat would merely change colour mid-flight. A failure that arms during an
+   * announcement beat must wait for that beat to end, or it would run only as
+   * its final fraction.
+   *
+   * A failure's beat is followed by a pill, and the whole 3.4-second gesture
+   * holds this one slot for its full duration. That is not a second scheduling
+   * concept: reason 3 already says "another beat is running", and a gesture is
+   * simply a longer beat.
+   */
+  private startSignalPulse;
+  private stopSignalPulse;
+  /**
+   * Runs a deferred beat if it can land now, and drops it if its reason to
+   * exist has gone: a nudge about a problem that no longer exists is worse
+   * than no nudge at all.
+   */
+  private flushPendingSignalPulse;
+  /**
+   * Drops a signal's gesture, pending or running, when the signal goes quiet.
+   *
+   * The pill closes early: it states a condition, and the condition has
+   * stopped being true. The beat is left to finish, because a beat asserts
+   * nothing — it says *here*, and "here" is still true.
+   */
+  private retireSignal;
+  /**
+   * The signal holding the single gesture slot: a beat in flight, or the pill
+   * and spoken sentence that follow it. One slot, not two — see reason 3 in
+   * `startSignalPulse`.
+   */
+  private get gestureSlotSignal();
+  /**
+   * Opens the gesture's tail alongside the beat, for a signal that carries a
+   * pill. The pill is rendered immediately — clipped to nothing, so it shows
+   * nothing — because its full width has to be on the page before the room
+   * either side of the launcher can be measured.
+   *
+   * A signal with no pill label gets no tail at all, so the announcement's
+   * gesture is exactly the beat it has always been.
+   */
+  private beginGestureTail;
+  /**
+   * Chooses the side, or suppresses the pill, from the room actually available
+   * at gesture start. Measured once, from the DOM, because the launcher is
+   * draggable and its position persists: a reader who parked it near the left
+   * edge would otherwise get a permanently truncated pill.
+   *
+   * Where neither side has room there is no pill at all rather than a cut-off
+   * one — the dot and the beat still fire, so the signal is intact and only
+   * the label is lost. Constraining where the reader may drag the control to
+   * protect this animation was considered and rejected: the page is theirs.
+   */
+  private resolvePillDirection;
+  /** Records the measurement's verdict, and drops the pill when it is null. */
+  private setPillOutcome;
+  /** Runs the pill's three phases in series once the beat has finished. */
+  private openPill;
+  private advancePill;
+  /**
+   * Closes the pill before its hold is out, because the failure it names has
+   * been fixed. A pill that has not opened yet is simply dropped; the beat is
+   * never cut short.
+   */
+  private closePillEarly;
+  /** Releases the slot and leaves the plain mark with its dot behind. */
+  private endGesture;
+  /**
+   * Drops the gesture's tail outright, with no closing animation, for the
+   * cases where the launcher itself has gone: the panel opened over it, or the
+   * element was removed from the page.
+   */
+  private cancelGestureTail;
+  private cancelPillTimeout;
+  /**
+   * Whether each error source is currently broken.
+   *
+   * Only two *wiring* conditions qualify. App errors (runs, tools, memory)
+   * are unread events on a different latch — they name themselves on the pill
+   * and clear when their landing view is read. Notably absent from *this*
+   * latch:
+   *
+   * - **A failed agent run.** A run is an event. It arms `run`, not this
+   *   state. The resting wiring dot must not stay red for the rest of a debug
+   *   hour.
+   * - **The core error channel as a wiring source.** Handshake failure already
+   *   sets the connection state. Other codes arm `run` or `tool`.
+   * - **Memory failures before Learning is live.** The memory store is lazy
+   *   because creating it opens a realtime connection. Once it exists, a load
+   *   failure arms `memory`.
+   * - **Product states.** An unconfigured Intelligence and an unentitled
+   *   Memory plan are not defects. The signal fires only where wiring is
+   *   present and the call still fails — which for threads is guaranteed by
+   *   `_threadsErrorByAgent` only ever being written while the thread
+   *   endpoints are available.
+   *
+   * Known limitation: the runtime handshake runs once, on connect. A server
+   * that dies *after* the page loaded leaves the connection state at connected
+   * and raises nothing; the next page load re-runs the handshake and the
+   * signal appears then. The signal reports the wiring state as last
+   * established. Closing that gap means a re-probe in the core, which is a
+   * runtime concern.
+   */
+  private isErrorSourceBroken;
+  /**
+   * Mirrors both error latches onto the live state. Called from `willUpdate`,
+   * because every mutation of the underlying state already requests an update,
+   * so the resting dot follows the state within the same render.
+   */
+  private evaluateErrorSignals;
+  /**
+   * Applies the rising-edge rule after a latch changed.
+   *
+   * The beat fires on the transition from "no failure" to "at least one
+   * failure", evaluated globally across the sources and never again while
+   * anything is red — one root cause, one nudge.
+   */
+  private onErrorSignalsChanged;
+  /**
+   * Records `oss.inspector.error_signal_viewed` once per source per outage,
+   * when the dot is actually on screen.
+   *
+   * Unlike the announcement's launcher event this fires immediately rather
+   * than waiting for the runtime handshake to report `telemetryDisabled`.
+   * The held-queue would never drain for the connection source — a connection
+   * failure means the handshake did not complete — so queuing would guarantee
+   * zero data for the case this event exists to measure. `trackOpened` already
+   * sends on the same terms. Both opt-out layers still gate it: the local
+   * opt-out inside `track`, and the runtime's flag once it is known.
+   */
+  private maybeTrackErrorSignalViewed;
+  private maybeTrackNewsSignalViewed;
+  /** Which of the three What's new states the feed currently supports. */
+  private getWhatsNewState;
   /**
    * Which announcement surface is on screen right now, or null when the
-   * announcement isn't visible. Mirrors the render gates in
-   * `renderAnnouncementPreview` (bubble) and `renderAnnouncementBanner`
-   * (in-panel card) — opening the panel clears `showAnnouncementPreview`, so
-   * the two are mutually exclusive.
+   * announcement isn't visible. What's new is the only surface: an impression
+   * requires the panel open, that view selected, and content actually
+   * rendered — a loading state is not an impression.
    */
   private getVisibleBannerSurface;
   /**
-   * Records a `banner_viewed` impression for whichever surface is currently
-   * visible, once per announcement per surface.
+   * The single condition that retires the news signal: What's new has
+   * rendered *with content*.
+   *
+   * Deliberately not on panel open — the common reason to open the Inspector
+   * is AG-UI events, and clearing there would burn a whole announcement
+   * silently and turn "viewed" into "opened the Inspector at some point".
+   * Deliberately not behind an acknowledge button, which is a dismiss button
+   * under another name. And a loading state does not count, because the feed
+   * is asynchronous and a reader who arrived early has seen nothing.
+   *
+   * The launcher dot and the navigation marker both read the same signal, so
+   * the two can never disagree about whether something has been read.
+   */
+  private maybeCompleteWhatsNewView;
+  /**
+   * Records a `whats_new_viewed` impression for whichever surface is
+   * currently visible, once per announcement per surface.
    */
-  private maybeTrackBannerViewed;
-  private flushPendingBannerViewed;
+  private maybeTrackWhatsNewViewed;
+  private flushPendingWhatsNewTelemetry;
   private ensureAnnouncementLoading;
-  private renderAnnouncementPreview;
-  private handleAnnouncementPreviewClick;
-  private handleDismissAnnouncementPreview;
-  private dismissAnnouncement;
   private fetchAnnouncement;
   private convertMarkdownToHtml;
   private isSafeAnnouncementHref;
@@ -872,9 +1333,6 @@ declare class WebInspectorElement extends LitElement {
   private appendRefParam;
   private isCopilotKitDestination;
   private escapeHtmlAttr;
-  private loadStoredAnnouncementTimestamp;
-  private persistAnnouncementTimestamp;
-  private markAnnouncementSeen;
 }
 declare function defineWebInspector(registry?: CustomElementRegistry | undefined): void;
 declare global {
@@ -883,5 +1341,5 @@ declare global {
   }
 } //# sourceMappingURL=index.d.ts.map
 //#endregion
-export { type Anchor, CpkThreadInspector, InspectorOpenOptions, THREAD_INSPECTOR_TAG, ThreadDebuggerEvent, ThreadDebuggerMessage, ThreadDebuggerMetadata, ThreadDebuggerProvider, ThreadDebuggerProviderLoadOptions, ThreadDebuggerToolCall, WEB_INSPECTOR_TAG, WebInspectorElement, defineWebInspector, type CapabilityToolRow as ɵCapabilityToolRow, ɵCpkThreadDetails, buildCapabilityRows as ɵbuildCapabilityRows, maxRecallScore as ɵmaxRecallScore, normalizeRelevance as ɵnormalizeRelevance, relevanceBarWidth as ɵrelevanceBarWidth };
+export { type ActivitySnippetMessage, type Anchor, type ChatSnippetCapture, CpkThreadInspector, type EventSnippet, InspectorOpenOptions, THREAD_INSPECTOR_TAG, ThreadDebuggerEvent, ThreadDebuggerMessage, ThreadDebuggerMetadata, ThreadDebuggerProvider, ThreadDebuggerProviderLoadOptions, ThreadDebuggerToolCall, WEB_INSPECTOR_TAG, WebInspectorElement, compileChatSnippet, compileFromActivityMessage, defineWebInspector, upsertEventSnippet, type CapabilityToolRow as ɵCapabilityToolRow, ɵCpkThreadDetails, buildCapabilityRows as ɵbuildCapabilityRows, maxRecallScore as ɵmaxRecallScore, normalizeRelevance as ɵnormalizeRelevance, relevanceBarWidth as ɵrelevanceBarWidth };
 //# sourceMappingURL=index.d.mts.map