gloomberb 0.11.0 → 0.11.2

package/src/plugins/builtin/account-management/pane.tsx

@@ -357,7 +357,7 @@ export function AccountManagementPane({ focused, width, height }: PaneProps) {
   const cachedFinancials = useAppSelector((state) => state.financials);
   const cachedExchangeRates = useAppSelector((state) => state.exchangeRates);
   const [sessionMarker, setSessionMarker] = useState(() => buildAccountSessionMarker());
-  const [hasSession, setHasSession] = useState(() => !!apiClient.getSessionToken());
+  const [hasSession, setHasSession] = useState(() => apiClient.isSignedIn());
   const [profile, setProfile] = useState<AccountProfile | null>(null);
   const [pricing, setPricing] = useState<CloudPricing | null>(null);
   const [draft, setDraft] = useState<AccountDraft>(() => profileToDraft(null));
@@ -552,7 +552,7 @@ export function AccountManagementPane({ focused, width, height }: PaneProps) {
 
   useEffect(() => {
     const unsubscribe = chatController.subscribe((snapshot) => {
-      setHasSession(!!apiClient.getSessionToken() || snapshot.hasSavedSession);
+      setHasSession(apiClient.isSignedIn() || snapshot.hasSavedSession);
       setSessionMarker(buildAccountSessionMarker());
     });
     void chatController.refreshSession().catch(() => {});
@@ -560,7 +560,7 @@ export function AccountManagementPane({ focused, width, height }: PaneProps) {
   }, []);
 
   const loadProfile = useCallback(async () => {
-    if (!apiClient.getSessionToken()) {
+    if (!apiClient.isSignedIn()) {
       setProfile(null);
       setDraft(profileToDraft(null));
       return;
@@ -598,7 +598,7 @@ export function AccountManagementPane({ focused, width, height }: PaneProps) {
   }, []);
 
   useEffect(() => {
-    if (!hasSession || !apiClient.getSessionToken()) return;
+    if (!hasSession || !apiClient.isSignedIn()) return;
     if (syncStatus.phase !== "synced" || syncStatus.revision == null) return;
     if (refreshedSyncRevisionRef.current === syncStatus.revision) return;
     refreshedSyncRevisionRef.current = syncStatus.revision;
@@ -847,7 +847,7 @@ export function AccountManagementPane({ focused, width, height }: PaneProps) {
     turnOffEmailAlerts,
   });
 
-  if (!hasSession && !apiClient.getSessionToken()) {
+  if (!hasSession && !apiClient.isSignedIn()) {
     return (
       <Box padding={1}>
         <CloudAuthNotice message={t("Log in to manage your Gloom Cloud account.")} />

package/src/plugins/builtin/ai/index.tsx

@@ -6,7 +6,10 @@ import {
   resolveDefaultAiProviderId,
   type AiProvider,
 } from "./providers";
-import { AiScreenerPane } from "./screener/pane";
+import {
+  AI_SCREENER_PANE_STATE_KEY,
+  AiScreenerPane,
+} from "./screener/pane";
 import { buildAiScreenerPaneSettingsDef, getAiScreenerPaneSettings } from "./settings";
 import {
   LOCAL_AGENT_WORKSPACE_SCHEMA_VERSION,
@@ -50,6 +53,7 @@ import {
   LIVE_STREAMING_QUICK_SETTING,
   withLiveStreamingSetting,
 } from "../shared/live-streaming";
+import { getPluginPaneStateValue } from "../../runtime";
 
 function settingOrFallback(
   settings: Record<string, unknown>,
@@ -269,6 +273,9 @@ export const aiPlugin: GloomPlugin = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 96, height: 32 },
+      portableShare: {
+        private: { title: true, params: true, settings: true, state: true },
+      },
       settings: (context) => {
         const providers = detectProviders();
         const workspaceProviders = providers.filter((provider) => (
@@ -335,7 +342,11 @@ export const aiPlugin: GloomPlugin = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 76, height: 24 },
+      tickerSource: true,
       quickSettings: [LIVE_STREAMING_QUICK_SETTING],
+      portableShare: {
+        private: { title: true, params: true, settings: true, state: true },
+      },
       settings: (context) => {
         const providers = detectProviders();
         const screenerProviders = providers.filter((provider) => (
@@ -347,7 +358,12 @@ export const aiPlugin: GloomPlugin = {
         const currentFallbackProviderId = resolveDefaultAiProviderId(screenerRunners);
         const defaults = defaultsFromConfig(context.config, currentFallbackProviderId);
         const providerIds = new Set(screenerProviders.map((provider) => provider.id));
-        const persisted = ctx.resume.getState<PersistedAiScreenerPaneState>(
+        const persisted = getPluginPaneStateValue<PersistedAiScreenerPaneState | null>(
+          context.paneState,
+          "ai",
+          AI_SCREENER_PANE_STATE_KEY,
+          null,
+        ) ?? ctx.resume.getState<PersistedAiScreenerPaneState>(
           `screener-pane:${context.paneId}`,
           { schemaVersion: 1 },
         ) ?? EMPTY_PANE_STATE;

package/src/plugins/builtin/ai/screener/pane.test.tsx

@@ -1,8 +1,14 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { act, useReducer, useState } from "react";
+import { act, useEffect, useReducer, useState } from "react";
 import { TestDialogProvider, testRender } from "../../../../renderers/opentui/test-utils";
 import { PaneFooterBar, PaneFooterProvider } from "../../../../components/layout/pane/footer";
-import { AppContext, PaneInstanceProvider, appReducer, createInitialState } from "../../../../state/app/context";
+import {
+  AppContext,
+  PaneInstanceProvider,
+  appReducer,
+  createInitialState,
+  type PaneRuntimeState,
+} from "../../../../state/app/context";
 import { createDefaultConfig } from "../../../../types/config";
 import type { Quote, TickerFinancials } from "../../../../types/financials";
 import type { TickerRecord } from "../../../../types/ticker";
@@ -11,7 +17,8 @@ import { createStatefulTestPluginRuntime } from "../../../../test-support/plugin
 import { Box } from "../../../../ui";
 import { PluginRenderProvider, type PluginRuntimeAccess } from "../../../runtime";
 import { getSharedMarketData, setSharedMarketDataForTests, setSharedRegistryForTests } from "../../../registry";
-import { AiScreenerPane } from "./pane";
+import { AI_SCREENER_PANE_STATE_KEY, AiScreenerPane } from "./pane";
+import { createScreenerTab, EMPTY_PANE_STATE } from "./model";
 import { setDetectedProviders, type AiProvider } from "../providers";
 import { setAiRunHost, setAiRuntimeCatalog, type AiRunHost } from "../runner";
 
@@ -99,10 +106,14 @@ function ScreenerHarness({
   prompt,
   providerId,
   settings,
+  runtime: runtimeOverride,
+  onPaneState,
 }: {
   prompt: string;
   providerId: string;
   settings?: Record<string, unknown>;
+  runtime?: PluginRuntimeAccess;
+  onPaneState?: (state: PaneRuntimeState | undefined) => void;
 }) {
   const config = createDefaultConfig("/tmp/gloomberb-ai-screener");
   config.layout.instances.push({
@@ -129,7 +140,11 @@ function ScreenerHarness({
     ]);
     return initial;
   });
-  const [runtime] = useState(() => makeRuntime());
+  const [runtime] = useState(() => runtimeOverride ?? makeRuntime());
+
+  useEffect(() => {
+    onPaneState?.(state.paneState[PANE_ID]);
+  }, [onPaneState, state.paneState]);
 
   return (
     <AppContext value={{ state, dispatch }}>
@@ -185,6 +200,34 @@ afterEach(() => {
 });
 
 describe("AiScreenerPane", () => {
+  test("migrates legacy global tabs into pane-local state", async () => {
+    const runtime = makeRuntime();
+    const legacyState = {
+      tabs: [createScreenerTab("Find legacy candidates.", "anthropic")],
+    };
+    runtime.setResumeState("ai", `screener-pane:${PANE_ID}`, legacyState, 1);
+    setDetectedProviders([makeProvider("anthropic", "Claude")]);
+    let paneState: PaneRuntimeState | undefined;
+
+    testSetup = await testRender(
+      <ScreenerHarness
+        prompt=""
+        providerId="anthropic"
+        runtime={runtime}
+        onPaneState={(state) => { paneState = state; }}
+      />,
+      { width: 96, height: 18 },
+    );
+
+    await act(async () => {
+      await testSetup!.renderOnce();
+      await Bun.sleep(0);
+      await testSetup!.renderOnce();
+    });
+    expect(paneState?.pluginState?.ai?.[AI_SCREENER_PANE_STATE_KEY]).toEqual(legacyState);
+    expect(runtime.getResumeState("ai", `screener-pane:${PANE_ID}`, 1)).toEqual(EMPTY_PANE_STATE);
+  });
+
   test("shows the account connection message before trying to run", async () => {
     const provider = makeProvider("anthropic", "Claude");
     setDetectedProviders([provider]);

package/src/plugins/builtin/ai/screener/pane.tsx

@@ -1,20 +1,20 @@
 import { Box, Text } from "../../../../ui";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState, type SetStateAction } from "react";
 import type { PaneProps } from "../../../../types/plugin";
-import { TICKER_RESEARCH_PANE_ID } from "../../../../types/config";
 import {
   useAppDispatch,
   useAppSelector,
   usePaneInstance,
   usePaneInstanceId,
+  usePaneStateValue,
 } from "../../../../state/app/context";
 import {
   useAssetData,
   usePluginConfigState,
   usePluginPaneState,
   usePluginState,
-  usePluginTickerActions,
 } from "../../../runtime";
+import { useTickerSourceActivate } from "../../shared/ticker-source";
 import { type DataTableKeyEvent } from "../../../../components";
 import { colors } from "../../../../theme/colors";
 import { t } from "../../../../i18n";
@@ -55,9 +55,11 @@ import {
 import { AGE_TICK_MS } from "../../shared/auto-refresh";
 import { useLiveStreamingSetting } from "../../shared/live-streaming";
 
+export const AI_SCREENER_PANE_STATE_KEY = "screener";
+
 export function AiScreenerPane({ focused, width, height }: PaneProps) {
   const dataProvider = useAssetData();
-  const { pinTicker } = usePluginTickerActions();
+  const activateTicker = useTickerSourceActivate();
   const paneId = usePaneInstanceId();
   const paneInstance = usePaneInstance();
   const liveStreaming = useLiveStreamingSetting();
@@ -79,13 +81,27 @@ export function AiScreenerPane({ focused, width, height }: PaneProps) {
   );
   const defaultProviderId = defaults.providerId;
   const defaultModelId = defaults.modelId;
-  const [persistedState, setPersistedState] = usePluginState<PersistedAiScreenerPaneState>(
+  const [legacyPersistedState, setLegacyPersistedState] = usePluginState<PersistedAiScreenerPaneState>(
     `screener-pane:${paneId}`,
     EMPTY_PANE_STATE,
     { schemaVersion: 1 },
   );
+  const [panePersistedState, setPanePersistedState] = usePluginPaneState<PersistedAiScreenerPaneState | null>(
+    AI_SCREENER_PANE_STATE_KEY,
+    null,
+  );
+  const persistedState = panePersistedState ?? legacyPersistedState;
+  const setPersistedState = useCallback((nextValue: SetStateAction<PersistedAiScreenerPaneState>) => {
+    setPanePersistedState((currentValue) => {
+      const previousValue = currentValue ?? legacyPersistedState;
+      return typeof nextValue === "function"
+        ? (nextValue as (previous: PersistedAiScreenerPaneState) => PersistedAiScreenerPaneState)(previousValue)
+        : nextValue;
+    });
+  }, [legacyPersistedState, setPanePersistedState]);
   const [activeTabId, setActiveTabId] = usePluginPaneState<string | null>("activeTabId", null);
-  const [cursorSymbol, setCursorSymbol] = usePluginPaneState<string | null>("cursorSymbol", null);
+  // Top-level pane state, not plugin-scoped: this is what follower panes resolve.
+  const [cursorSymbol, setCursorSymbol] = usePaneStateValue<string | null>("cursorSymbol", null);
   const [sorts, setSorts] = usePluginPaneState<Record<string, ScreenerSortPreference>>("sorts", {});
   const [now, setNow] = useState(Date.now());
   const initializedRef = useRef(false);
@@ -98,6 +114,15 @@ export function AiScreenerPane({ focused, width, height }: PaneProps) {
   }, []);
 
   const tabs = useMemo(() => normalizeTabs(persistedState), [persistedState]);
+
+  // ponytail: legacy global data is ambiguous across layouts; the first mounted pane claims it.
+  useEffect(() => {
+    const legacyTabs = normalizeTabs(legacyPersistedState);
+    if (legacyTabs.length === 0) return;
+    if (panePersistedState === null) setPanePersistedState({ tabs: legacyTabs });
+    setLegacyPersistedState(EMPTY_PANE_STATE);
+  }, [legacyPersistedState, panePersistedState, setLegacyPersistedState, setPanePersistedState]);
+
   const paneSettings = useMemo(
     () => getAiScreenerPaneSettings(paneInstance?.settings),
     [paneInstance?.settings],
@@ -301,12 +326,9 @@ export function AiScreenerPane({ focused, width, height }: PaneProps) {
     if (!isEnter || !cursorSymbol) return false;
     event.preventDefault?.();
     event.stopPropagation?.();
-    pinTicker(cursorSymbol, {
-      floating: !!event.shift,
-      paneType: TICKER_RESEARCH_PANE_ID,
-    });
+    activateTicker(cursorSymbol, { floating: !!event.shift, newPane: !!event.shift });
     return true;
-  }, [cursorSymbol, pinTicker]);
+  }, [activateTicker, cursorSymbol]);
 
   const contentHeight = Math.max(height - 3, 4);
   const editorProvider = editorState ? getAiProvider(editorState.providerId, providers) : null;
@@ -406,7 +428,8 @@ export function AiScreenerPane({ focused, width, height }: PaneProps) {
           onHeaderClick={handleHeaderClick}
           onRootKeyDown={handleTableKeyDown}
           onRowActivate={(ticker) => {
-            pinTicker(ticker.metadata.ticker, { floating: true, paneType: TICKER_RESEARCH_PANE_ID });
+            setCursorSymbol(ticker.metadata.ticker);
+            activateTicker(ticker.metadata.ticker, { floating: true });
           }}
         />
       )}

package/src/plugins/builtin/alerts/alert-engine.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { evaluateAlert, createAlert, serializeAlerts, deserializeAlerts } from "./alert-engine";
+import { evaluateAlert, createAlert, editAlert, rearmAlert, serializeAlerts, deserializeAlerts } from "./alert-engine";
 
 describe("evaluateAlert", () => {
   test("above: triggers when price exceeds target", () => {
@@ -41,6 +41,58 @@ describe("evaluateAlert", () => {
   });
 });
 
+describe("editAlert", () => {
+  test("keeps identity, re-arms, and clears trigger/quote lifecycle state", () => {
+    const alert = {
+      ...createAlert("aapl", "above", 200, "NASDAQ"),
+      message: "watch this",
+      status: "triggered" as const,
+      triggeredAt: 123,
+      lastCheckedPrice: 205,
+      lastCheckedAt: 124,
+      lastCheckError: "boom",
+      lastQuoteUpdatedAt: 125,
+      lastQuoteSource: "live" as const,
+      lastQuoteProviderId: "yahoo",
+    };
+
+    const edited = editAlert(alert, "aapl", "crosses", 180);
+
+    expect(edited).toEqual({
+      id: alert.id,
+      symbol: "AAPL",
+      exchange: "NASDAQ",
+      condition: "crosses",
+      targetPrice: 180,
+      createdAt: alert.createdAt,
+      status: "active",
+      message: "watch this",
+    });
+    // A stale lastCheckedPrice would make `crosses` fire off the previous symbol's baseline.
+    expect(evaluateAlert(edited, 185)).toBe(false);
+  });
+
+  test("rearming a crosses alert drops the old quote baseline", () => {
+    const alert = {
+      ...createAlert("AAPL", "crosses", 180),
+      status: "triggered" as const,
+      triggeredAt: 123,
+      lastCheckedPrice: 185,
+    };
+
+    const rearmed = rearmAlert(alert);
+
+    expect(rearmed.status).toBe("active");
+    expect(rearmed.lastCheckedPrice).toBeUndefined();
+    expect(evaluateAlert(rearmed, 175)).toBe(false);
+  });
+
+  test("drops the exchange when the symbol changes", () => {
+    const alert = createAlert("AAPL", "above", 200, "NASDAQ");
+    expect(editAlert(alert, "tsla", "above", 200).exchange).toBeUndefined();
+  });
+});
+
 describe("serializeAlerts / deserializeAlerts", () => {
   test("roundtrips alerts", () => {
     const alerts = [createAlert("AAPL", "above", 200), createAlert("TSLA", "below", 100)];

package/src/plugins/builtin/alerts/alert-engine.ts

@@ -2,10 +2,16 @@ import type { AlertCondition, AlertRule } from "./types";
 
 export type { AlertRule };
 
-export function createAlert(symbol: string, condition: AlertCondition, targetPrice: number): AlertRule {
+export function createAlert(
+  symbol: string,
+  condition: AlertCondition,
+  targetPrice: number,
+  exchange?: string,
+): AlertRule {
   return {
     id: `alert-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`,
     symbol: symbol.toUpperCase(),
+    exchange: exchange?.trim() || undefined,
     condition,
     targetPrice,
     createdAt: Date.now(),
@@ -13,6 +19,33 @@ export function createAlert(symbol: string, condition: AlertCondition, targetPri
   };
 }
 
+/**
+ * Rebuilt from a whitelist rather than spread so every trigger/quote lifecycle
+ * field is dropped: a re-armed `crosses` alert must start from a fresh baseline.
+ */
+export function editAlert(
+  alert: AlertRule,
+  symbol: string,
+  condition: AlertCondition,
+  targetPrice: number,
+): AlertRule {
+  const nextSymbol = symbol.trim().toUpperCase();
+  return {
+    id: alert.id,
+    symbol: nextSymbol,
+    exchange: nextSymbol === alert.symbol.trim().toUpperCase() ? alert.exchange : undefined,
+    condition,
+    targetPrice,
+    createdAt: alert.createdAt,
+    status: "active",
+    message: alert.message,
+  };
+}
+
+export function rearmAlert(alert: AlertRule): AlertRule {
+  return editAlert(alert, alert.symbol, alert.condition, alert.targetPrice);
+}
+
 export function evaluateAlert(alert: AlertRule, currentPrice: number): boolean {
   if (alert.status !== "active") return false;
 

package/src/plugins/builtin/alerts/index.test.tsx

@@ -148,13 +148,14 @@ function storedAlerts(): AlertRule[] {
   return JSON.parse(value);
 }
 
-afterEach(() => {
+afterEach(async () => {
   harnessState = null;
   harnessDispatch = null;
-  if (testSetup) {
-    testSetup.renderer.destroy();
-    testSetup = undefined;
-  }
+  if (!testSetup) return;
+  await act(async () => {
+    testSetup!.renderer.destroy();
+  });
+  testSetup = undefined;
 });
 
 describe("AlertsPane", () => {
@@ -179,6 +180,7 @@ describe("AlertsPane", () => {
     expect(frame).toContain("AAPL");
     expect(frame).toContain("MSFT");
     expect(frame).toContain("[a]dd alert");
+    expect(frame).toContain("[e]dit");
     expect(frame).toContain("[d]elete");
     expect(frame).not.toContain("Add Alert");
     expect(frame).not.toContain("Enter");
@@ -209,6 +211,45 @@ describe("AlertsPane", () => {
     expect(frame).toContain("[a]dd alert");
   });
 
+  test("edits the selected alert through the prefilled edit dialog", async () => {
+    testSetup = await testRender(
+      <AlertsHarness alerts={[makeAlert("alert-aapl", "AAPL", "above", 200)]} />,
+      { width: 110, height: 12 },
+    );
+
+    await renderSettled();
+    await act(async () => {
+      await testSetup!.mockInput.typeText("e");
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    const dialogFrame = testSetup.captureCharFrame();
+    expect(dialogFrame).toContain("Edit alert");
+    expect(dialogFrame).toContain("AAPL above 200");
+
+    await act(async () => {
+      for (const _ of "AAPL above 200") testSetup!.mockInput.pressBackspace();
+      await testSetup!.mockInput.typeText("MSFT crosses 310");
+      await testSetup!.renderOnce();
+    });
+
+    await act(async () => {
+      testSetup!.mockInput.pressEnter();
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    expect(storedAlerts()).toEqual([{
+      id: "alert-aapl",
+      symbol: "MSFT",
+      condition: "crosses",
+      targetPrice: 310,
+      createdAt: 1_700_000_000_000,
+      status: "active",
+    }]);
+  });
+
   test("opens the shared alert workflow from keyboard and mouse", async () => {
     const workflowCalls: string[] = [];
     const runtime = makeRuntime({
@@ -229,7 +270,9 @@ describe("AlertsPane", () => {
     });
     expect(workflowCalls).toEqual(["set-alert"]);
 
-    testSetup.renderer.destroy();
+    await act(async () => {
+      testSetup!.renderer.destroy();
+    });
     testSetup = await testRender(<AlertsHarness alerts={[]} runtime={runtime} />, {
       width: 110,
       height: 12,

package/src/plugins/builtin/alerts/index.tsx

@@ -102,13 +102,14 @@ export const alertsPlugin: GloomPlugin = {
 
       // One batched pass over the distinct symbols: the alerts pane reads the same
       // persisted store, so this is the only place that talks to the provider.
-      const symbols = [...new Set(activeAlerts.map((alert) => alert.symbol))];
-      const results = await Promise.all(symbols.map(async (symbol): Promise<[string, Quote | string]> => {
+      const quoteKeys = [...new Set(activeAlerts.map((alert) => `${alert.symbol}\0${alert.exchange ?? ""}`))];
+      const results = await Promise.all(quoteKeys.map(async (key): Promise<[string, Quote | string]> => {
+        const [symbol, exchange = ""] = key.split("\0");
         try {
-          return [symbol, await resolveAlertQuote(ctx.marketData, symbol)];
+          return [key, await resolveAlertQuote(ctx.marketData, symbol ?? "", exchange)];
         } catch (err) {
-          ctx.log.warn("poll: no quote", { symbol, error: String(err) });
-          return [symbol, createQuoteErrorMessage(symbol, err)];
+          ctx.log.warn("poll: no quote", { symbol, exchange, error: String(err) });
+          return [key, createQuoteErrorMessage(symbol ?? "", err)];
         }
       }));
       const quotes = new Map<string, Quote | string>(results);
@@ -116,7 +117,7 @@ export const alertsPlugin: GloomPlugin = {
       let changed = false;
       for (const alert of alerts) {
         if (alert.status !== "active") continue;
-        const quote = quotes.get(alert.symbol);
+        const quote = quotes.get(`${alert.symbol}\0${alert.exchange ?? ""}`);
         if (quote === undefined) continue;
         if (typeof quote === "string") {
           Object.assign(alert, quoteErrorAlertFields(quote));
@@ -134,6 +135,10 @@ export const alertsPlugin: GloomPlugin = {
             desktop: "always",
             persistent: true,
             sound: "Glass",
+            action: {
+              label: "Open",
+              onClick: () => ctx.showPane("alerts"),
+            },
           });
         }
         Object.assign(alert, quoteAlertFields(quote));

package/src/plugins/builtin/alerts/pane.tsx

@@ -6,15 +6,20 @@ import {
   type DataTableColumn,
   type DataTableKeyEvent,
 } from "../../../components";
+import { TextFieldDialog } from "../../../components/pane-settings-dialog/field-dialogs";
 import { colors } from "../../../theme/colors";
 import { TextAttributes } from "../../../ui";
+import { useDialog, type AlertContext } from "../../../ui/dialog";
 import type { PaneProps } from "../../../types/plugin";
 import { usePluginAppActions, usePluginConfigState } from "../../runtime";
 import {
   deserializeAlerts,
+  editAlert,
+  rearmAlert as rebuildAlert,
   readAlertsStoreError,
   serializeAlerts,
 } from "./alert-engine";
+import { parseAlertCommandValues } from "./command";
 import { ALERTS_KEY } from "./constants";
 import {
   conditionLabel,
@@ -59,6 +64,7 @@ const ALERT_TABLE_CONTENT_WIDTH = ALERT_COLUMNS.reduce(
 export function AlertsPane({ focused, width, height, close }: PaneProps) {
   const [alertsJson, setAlertsJson] = usePluginConfigState<string>(ALERTS_KEY, "[]");
   const { openPluginCommandWorkflow } = usePluginAppActions();
+  const dialog = useDialog();
   const [selectedIdx, setSelectedIdx] = useState(0);
   const showHorizontalScrollbar = ALERT_TABLE_CONTENT_WIDTH > width;
   const storeError = useMemo(() => readAlertsStoreError(alertsJson), [alertsJson]);
@@ -92,14 +98,7 @@ export function AlertsPane({ focused, width, height, close }: PaneProps) {
 
   const rearmAlert = useCallback((id: string) => {
     savePaneAlerts(
-      alerts.map((a) =>
-        a.id === id ? {
-          ...a,
-          status: "active" as const,
-          triggeredAt: undefined,
-          lastCheckError: undefined,
-        } : a,
-      ),
+      alerts.map((a) => (a.id === id ? rebuildAlert(a) : a)),
     );
   }, [alerts, savePaneAlerts]);
 
@@ -112,6 +111,36 @@ export function AlertsPane({ focused, width, height, close }: PaneProps) {
     if (selected) deleteAlert(selected.id);
   }, [deleteAlert, rows, selectedIdx]);
 
+  const editSelectedAlert = useCallback(() => {
+    const selected = rows[selectedIdx];
+    if (!selected) return;
+    void dialog.alert({
+      closeOnClickOutside: true,
+      content: (context: AlertContext) => (
+        <TextFieldDialog
+          {...context}
+          field={{
+            type: "text",
+            key: "alert",
+            label: "Edit alert",
+            description: "SYMBOL above|below|crosses PRICE",
+            placeholder: "AAPL above 200",
+          }}
+          currentValue={`${selected.symbol} ${selected.condition} ${selected.targetPrice}`}
+          onApply={async (value) => {
+            const parsed = parseAlertCommandValues({ shortcut: value });
+            if (!parsed) throw new Error("Use SYMBOL above|below|crosses PRICE.");
+            savePaneAlerts((current) => current.map((alert) => (
+              alert.id === selected.id
+                ? editAlert(alert, parsed.symbol, parsed.condition, parsed.price)
+                : alert
+            )));
+          }}
+        />
+      ),
+    });
+  }, [dialog, rows, savePaneAlerts, selectedIdx]);
+
   // Quotes come from the plugin's single background poll, which writes into the
   // same persisted store, so the pane never fetches on its own.
 
@@ -123,6 +152,13 @@ export function AlertsPane({ focused, width, height, close }: PaneProps) {
         : [],
     hints: [
       { id: "add", key: "a", label: "dd alert", onPress: startAddAlert },
+      {
+        id: "edit",
+        key: "e",
+        label: "dit",
+        onPress: editSelectedAlert,
+        disabled: rows.length === 0,
+      },
       {
         id: "delete",
         key: "d",
@@ -133,6 +169,7 @@ export function AlertsPane({ focused, width, height, close }: PaneProps) {
     ],
   }), [
     deleteSelectedAlert,
+    editSelectedAlert,
     quoteError,
     rows.length,
     startAddAlert,
@@ -154,13 +191,18 @@ export function AlertsPane({ focused, width, height, close }: PaneProps) {
       startAddAlert();
       return true;
     }
+    if (event.name === "e") {
+      event.preventDefault?.();
+      editSelectedAlert();
+      return true;
+    }
     if (event.name === "escape") {
       event.preventDefault?.();
       close?.();
       return true;
     }
     return false;
-  }, [close, deleteSelectedAlert, startAddAlert]);
+  }, [close, deleteSelectedAlert, editSelectedAlert, startAddAlert]);
 
   const renderCell = useCallback((
     alert: AlertRule,