gloomberb 0.13.2 → 0.14.0

package/src/app.tsx

@@ -12,6 +12,8 @@ import {
 import { bindAppActivity, useAppActive } from "./state/app/activity";
 import { Header } from "./components/layout/header";
 import { StatusBar } from "./components/layout/status-bar";
+import { useLinkedLayoutSync } from "./layout-marketplace/linked-sync";
+import { useTeamCollectionsSync } from "./plugins/builtin/cloud/team/collections-sync";
 import { Shell } from "./components/layout/shell";
 import { DetachedPaneShell } from "./components/layout/detached-pane-shell";
 import { TransientLayoutProvider } from "./components/layout/transient-layout";
@@ -52,6 +54,8 @@ import {
   resolveInitialAppConfig,
 } from "./app/app-bootstrap-state";
 import { scheduleConfigSave } from "./state/config-save-scheduler";
+import { LOW_PRIORITY_CONFIG_SAVE_DEBOUNCE_MS } from "./state/persist-scheduler";
+import { savedLayoutsDifferOnlyInMirror } from "./core/state/app/layout";
 import { measurePerf } from "./utils/perf-marks";
 import { useAppLanguage } from "./i18n/react";
 import { AppLanguageConfigObserver } from "./app/language-observer";
@@ -76,6 +80,8 @@ interface AppInnerProps {
   onOnboardingComplete?: (config: AppConfig) => void | Promise<void>;
   /** Hosted browser terminal: nothing is reachable until a session exists. */
   signInGateActive?: boolean;
+  /** Fires once the startup state is in place and the first real layout can paint. */
+  onInitialized?: () => void;
 }
 
 function ThemedAppRoot({ children }: { children: ReactNode }) {
@@ -111,15 +117,22 @@ function AppInner({
   onboardingActive = false,
   onOnboardingComplete,
   signInGateActive = false,
+  onInitialized,
 }: AppInnerProps) {
   const dispatch = useAppDispatch();
   const stateRef = useAppStateRef();
   const getRemoteState = useCallback(() => stateRef.current, [stateRef]);
+  useLinkedLayoutSync(pluginRegistry);
   const config = useAppSelector((state) => state.config);
   const tickers = useAppSelector((state) => state.tickers);
   const paneState = useAppSelector((state) => state.paneState);
   const focusedPaneId = useAppSelector((state) => state.focusedPaneId);
   const initialized = useAppSelector((state) => state.initialized);
+  const onInitializedRef = useRef(onInitialized);
+  onInitializedRef.current = onInitialized;
+  useEffect(() => {
+    if (initialized) onInitializedRef.current?.();
+  }, [initialized]);
   const commandBarOpen = useAppSelector((state) => state.commandBarOpen);
   const inputCaptured = useAppSelector((state) => state.inputCaptured);
   const updateAvailable = useAppSelector((state) => state.updateAvailable);
@@ -277,7 +290,9 @@ function AppInner({
     autoImportBrokerPositions,
     dataProvider,
     dispatch,
+    externalPlugins,
     focusedTickerSymbol,
+    isDetachedWindow,
     marketData,
     pluginRegistry,
     primeCachedFinancials,
@@ -318,6 +333,7 @@ function AppInner({
   const persistConfig = useCallback((nextConfig: AppState["config"]) => {
     scheduleConfigSave(nextConfig);
   }, []);
+  useTeamCollectionsSync({ persistConfig, tickerRepository });
 
   useAppPaneRuntime({
     dataProvider,
@@ -337,14 +353,20 @@ function AppInner({
   // Wire up app-level notifications.
   pluginRegistry.notifyFn = appNotifier.notify;
 
-  // Persist layout changes (switching, saving, deleting, renaming layouts)
+  // Persist layout changes (switching, saving, deleting, renaming layouts).
+  // The saved layouts also mirror live pane state and focus, so they change on
+  // every cursor move; those updates are written on the low-priority delay
+  // rather than paying a full config serialization per keystroke.
   const prevLayouts = useRef(state.config.layouts);
   useEffect(() => {
-    if (state.config.layouts !== prevLayouts.current) {
-      prevLayouts.current = state.config.layouts;
-      scheduleConfigSave(state.config);
-    }
-  }, [state.config.layouts, state.config]);
+    if (state.config.layouts === prevLayouts.current) return;
+    const mirrorOnly = savedLayoutsDifferOnlyInMirror(prevLayouts.current, state.config.layouts);
+    prevLayouts.current = state.config.layouts;
+    scheduleConfigSave(
+      () => stateRef.current.config,
+      mirrorOnly ? { delayMs: LOW_PRIORITY_CONFIG_SAVE_DEBOUNCE_MS } : {},
+    );
+  }, [state.config.layouts, state.config, stateRef]);
 
   // Emit ticker:selected events based on focused pane context.
   const prevSelectedRef = useRef(focusedTickerSymbol);
@@ -459,6 +481,8 @@ interface AppProps {
    * terminal sets this; desktop and the TUI keep sign-in optional.
    */
   requireSignIn?: boolean;
+  /** Fires once the startup state is in place and the first real layout can paint. */
+  onInitialized?: () => void;
 }
 
 export function App({
@@ -475,6 +499,7 @@ export function App({
   remoteControlAdapter,
   updatesEnabled = true,
   requireSignIn = false,
+  onInitialized,
 }: AppProps) {
   useAppLanguage();
   const externalPlugins = providedExternalPlugins ?? EMPTY_EXTERNAL_PLUGINS;
@@ -571,6 +596,7 @@ export function App({
           updatesEnabled={updatesEnabled}
           onboardingActive={showOnboarding}
           signInGateActive={signInGateActive}
+          onInitialized={onInitialized}
           onOnboardingComplete={(updatedConfig) => {
             setConfig(updatedConfig);
             setShowOnboarding(false);

package/src/architecture/browser-entry-graph.test.ts

@@ -30,6 +30,7 @@ const BUN_ONLY_MODULES = [
   "src/plugins/bundle.ts",
   "src/plugins/seed.ts",
   "src/plugins/host-link.ts",
+  "src/plugins/host-resolver.ts",
   "src/cli/restore-plugins.ts",
 ];
 

package/src/architecture/import-boundaries.test.ts

@@ -119,4 +119,18 @@ describe("import boundaries", () => {
 
     expect(violations).toEqual([]);
   });
+
+  test("plugin fields use shared controls instead of raw host inputs", async () => {
+    const files = await collectSourceFiles(join(SOURCE_ROOT, "plugins"));
+    const violations: string[] = [];
+    for (const file of files) {
+      const source = await Bun.file(file).text();
+      // Layout/text remain valid for domain rendering; single-line fields have
+      // one owner for focus, keyboard events, masking and renderer differences.
+      if (/import\s*\{[^}]*\bInput\b[^}]*\}\s*from\s*["'][^"']*\/ui(?:\/index)?["']/.test(source)) {
+        violations.push(relative(process.cwd(), file));
+      }
+    }
+    expect(violations).toEqual([]);
+  });
 });

package/src/brokers/bond-price-basis.test.ts

@@ -0,0 +1,35 @@
+import { expect, test } from "bun:test";
+import type { BrokerAdapter, BrokerPosition } from "../types/broker";
+import { createDefaultConfig } from "../types/config";
+import { AppPersistence } from "../data/app-persistence";
+import { TickerRepository } from "../data/ticker-repository";
+import { syncBrokerInstance } from "./sync-broker-instance";
+import { getPortfolioPositionMetrics } from "../plugins/builtin/portfolio-list/position-metrics";
+import { hydrateTickerMetadata } from "../tickers/metadata";
+
+test("bond basis survives import and SQLite; resync replaces declarations without inferring legacy units",async()=>{
+  const db=new AppPersistence(":memory:"); const tickerRepository=new TickerRepository(db.tickers);
+  const instance={id:"controlled",brokerType:"controlled",label:"Controlled",enabled:true,config:{}};
+  let position:BrokerPosition={ticker:"CONTROLLED",exchange:"",shares:1000,avgCost:87.742,currency:"USD",assetCategory:"BOND",markPrice:86.359375,multiplier:1,marketValue:863.59,unrealizedPnl:-13.83};
+  const adapter:BrokerAdapter={id:"controlled",name:"Controlled",configSchema:[],validate:async()=>true,importPositions:async()=>[position]};
+  const config={...createDefaultConfig("/unused-bond-basis"),brokerInstances:[instance]};
+  try {
+    for(const basis of [undefined,"percent-of-par",undefined,"per-unit"] as const) {
+      position={...position,priceBasis:basis};
+      await syncBrokerInstance({config,instanceId:instance.id,brokers:new Map([[adapter.id,adapter]]),tickerRepository});
+      const r=(await tickerRepository.loadTicker("CONTROLLED"))!;
+      const persisted=JSON.parse(JSON.stringify(r));
+      expect(persisted.metadata.positions[0]).toMatchObject({shares:1000,avgCost:87.742,markPrice:86.359375,multiplier:1});
+      expect(persisted.metadata.positions[0].priceBasis).toBe(basis);
+      const metrics=getPortfolioPositionMetrics(r,undefined,"USD");
+      if(basis===undefined)expect(metrics.totalCost).toBeNaN();
+      else expect(metrics.totalCost).toBeCloseTo(basis==="percent-of-par"?877.42:87742,8);
+      expect(metrics.brokerMktValue).toBe(863.59);expect(metrics.brokerPnl).toBe(-13.83);
+    }
+    const stored=(await tickerRepository.loadTicker("CONTROLLED"))!;
+    for(const invalid of [null,"", "unknown", 0]) {
+      const hydrated=hydrateTickerMetadata({...stored.metadata,positions:[{...stored.metadata.positions[0],priceBasis:invalid}]});
+      expect(hydrated.positions[0]!.priceBasis).toBeUndefined();
+    }
+  } finally {db.close();}
+});

package/src/brokers/broker-ticker-sync.ts

@@ -3,6 +3,7 @@ import type { BrokerPosition } from "../types/broker";
 import type { BrokerInstanceConfig } from "../types/config";
 import type { BrokerContractRef } from "../types/instrument";
 import type { TickerMetadata, TickerPosition, TickerRecord } from "../types/ticker";
+import { brokerContractIdentityKey, scopedBrokerContractIdentityKey } from "../utils/instrument-identity";
 
 export async function loadTickerMap(
   tickerRepository: AppTickerRepositoryPort,
@@ -19,7 +20,7 @@ export async function loadTickerMap(
 function mergeBrokerContracts(existing: BrokerContractRef[], next: BrokerContractRef[]): BrokerContractRef[] {
   const merged = new Map<string, BrokerContractRef>();
   for (const contract of [...existing, ...next]) {
-    const key = `${contract.brokerId}:${contract.brokerInstanceId ?? ""}:${contract.conId ?? contract.localSymbol ?? contract.symbol}:${contract.secType ?? ""}`;
+    const key = scopedBrokerContractIdentityKey(contract);
     merged.set(key, contract);
   }
   return [...merged.values()];
@@ -34,8 +35,10 @@ function buildPositionEntry(
   return {
     portfolio: portfolioId,
     shares: position.shares,
-    avgCost: position.avgCost ?? 0,
+    avgCost: typeof position.avgCost === "number" && Number.isFinite(position.avgCost) ? position.avgCost : undefined,
+    priceBasis: position.priceBasis,
     currency: position.currency,
+    dateAcquired: position.dateAcquired,
     broker: instance.brokerType,
     side: position.side,
     marketValue: position.marketValue,
@@ -45,6 +48,7 @@ function buildPositionEntry(
     brokerInstanceId: instance.id,
     brokerAccountId: position.accountId,
     brokerContractId: brokerContract?.conId,
+    brokerContractIdentity: brokerContract && brokerContract.conId == null ? brokerContractIdentityKey(brokerContract) : undefined,
   };
 }
 

package/src/brokers/legacy-contract.test.ts

@@ -0,0 +1,51 @@
+import { expect, test } from "bun:test";
+import { AppPersistence } from "../data/app-persistence";
+import { instrumentFromTicker } from "../market-data/request-types";
+import { hydrateTickerMetadata } from "../tickers/metadata";
+import type { BrokerPosition } from "../types/broker";
+import type { BrokerInstanceConfig } from "../types/config";
+import type { TickerRecord } from "../types/ticker";
+import { brokerContractIdentityKey } from "../utils/instrument-identity";
+import { upsertBrokerPositionTicker } from "./broker-ticker-sync";
+
+const instance = { id: "feed", brokerType: "fixture", name: "Fixture", enabled: true, settings: {} } as BrokerInstanceConfig;
+const position = (strike: number, accountId: string): BrokerPosition => ({ ticker: "ACME", exchange: "NASDAQ", shares: 1, avgCost: 5, currency: "USD", accountId, multiplier: 100, brokerContract: { brokerId: "fixture", symbol: "ACME", localSymbol: "LEGACY", secType: "OPT", currency: "USD", exchange: "SMART", lastTradeDateOrContractMonth: "20261016", right: "C", strike, multiplier: "100" } });
+
+test("sync and persisted hydration preserve separate account definitions through a replacement", () => {
+  const persistence = new AppPersistence(":memory:");
+  const tickers = new Map<string, TickerRecord>();
+  const apply = (strike: number, portfolioId: string) => {
+    const { ticker } = upsertBrokerPositionTicker({ tickers, instance, portfolioId, position: position(strike, portfolioId) });
+    persistence.tickers.save("ACME", ticker.metadata);
+    const hydrated = { metadata: hydrateTickerMetadata(JSON.parse(persistence.tickers.get("ACME")!)) };
+    tickers.set("ACME", hydrated); return hydrated;
+  };
+  try {
+    apply(100, "a"); const both = apply(110, "b");
+    expect(both.metadata.broker_contracts).toHaveLength(2);
+    expect(instrumentFromTicker(both, "ACME", { portfolioId: "a" })?.instrument?.strike).toBe(100);
+    expect(instrumentFromTicker(both, "ACME", { portfolioId: "b" })?.instrument?.strike).toBe(110);
+    const replacement = apply(120, "a");
+    expect(instrumentFromTicker(replacement, "ACME", { portfolioId: "a" })?.instrument?.strike).toBe(120);
+    expect(instrumentFromTicker(replacement, "ACME", { portfolioId: "b" })?.instrument?.strike).toBe(110);
+    expect(replacement.metadata.positions).toHaveLength(2);
+    const saved = replacement.metadata.positions.find(p => p.portfolio === "a")!;
+    expect(saved.brokerContractIdentity).toBe(brokerContractIdentityKey(position(120, "a").brokerContract!));
+    expect(saved.brokerContractId).toBeUndefined();
+    expect(saved.avgCost).toBe(5); expect(saved.multiplier).toBe(100);
+  } finally { persistence.close(); }
+});
+
+test("explicit fallback identity cannot widen and old records retain unique legacy matching", () => {
+  const tickers = new Map<string, TickerRecord>();
+  const ticker = upsertBrokerPositionTicker({ tickers, instance, portfolioId: "a", position: position(100, "a") }).ticker;
+  const lot = ticker.metadata.positions[0]!;
+  delete lot.brokerContractIdentity;
+  expect(instrumentFromTicker(ticker, "ACME", { portfolioId: "a" })?.instrument?.strike).toBe(100);
+  lot.brokerContractIdentity = "unknown-version:unmatched";
+  expect(instrumentFromTicker(ticker, "ACME", { portfolioId: "a" })).toBeNull();
+  lot.brokerContractId = 123; ticker.metadata.broker_contracts![0]!.conId = 123;
+  expect(instrumentFromTicker(ticker, "ACME", { portfolioId: "a" })?.instrument?.conId).toBe(123);
+  lot.brokerContractId = 999;
+  expect(instrumentFromTicker(ticker, "ACME", { portfolioId: "a" })).toBeNull();
+});

package/src/brokers/sync-broker-instance.test.ts

@@ -2,7 +2,15 @@ import { describe, expect, test } from "bun:test";
 import { createDefaultConfig, type BrokerInstanceConfig } from "../types/config";
 import type { BrokerAdapter } from "../types/broker";
 import type { TickerRecord } from "../types/ticker";
+import { hydrateTickerMetadata } from "../tickers/metadata";
 import { AppPersistence } from "../data/app-persistence";
+import { TickerRepository } from "../data/ticker-repository";
+import { getColumnValue, getSortValue } from "../plugins/builtin/portfolio-list/column-values";
+import { showCollection } from "../plugins/builtin/portfolio-list/cli/render";
+import { createTestDataProvider } from "../test-support/data-provider";
+import { DEFAULT_CLI_OPTIONS } from "../cli/options";
+import type { CliResult } from "../cli/result";
+import type { CliCommandContext } from "../types/plugin";
 import { loadPersistedBrokerAccounts, persistBrokerAccounts } from "./account-cache";
 import {
   restoreBrokerPortfoliosFromTickerPositions,
@@ -125,6 +133,68 @@ function createMultiAccountDemoBroker(): BrokerAdapter {
 }
 
 describe("syncBrokerInstance", () => {
+  test("preserves unavailable imported cost across serialization and replaces it only on source recovery", async () => {
+    const repository = createTickerRepository();
+    let sourceCost: number | undefined;
+    const adapter = createDemoBroker();
+    adapter.importPositions = async () => [{ ticker: "AAPL", exchange: "NASDAQ", shares: 10,
+      currency: "USD", accountId: "ACC-1", avgCost: sourceCost, unrealizedPnl: 200, marketValue: 1200 }];
+    let config = { ...createDefaultConfig("/unused-import-cost"), portfolios: [], brokerInstances: [createBrokerInstance()] };
+    for (const cost of [undefined, Number.NaN, Infinity, 0, 100, undefined]) {
+      sourceCost = cost;
+      const result = await syncBrokerInstance({ config, instanceId: "demo-broker", brokers: new Map([["demo", adapter]]), tickerRepository: repository as any });
+      config = result.config as typeof config;
+      const imported = result.tickers.get("AAPL")!;
+      const reloaded = hydrateTickerMetadata(JSON.parse(JSON.stringify(imported.metadata)));
+      expect(imported.metadata.positions[0]!.avgCost).toBe(Number.isFinite(cost) ? cost : undefined);
+      expect(reloaded.positions[0]!.avgCost).toBe(Number.isFinite(cost) ? cost : undefined);
+      expect(reloaded.positions[0]).toMatchObject({ shares: 10, unrealizedPnl: 200, marketValue: 1200 });
+      expect(reloaded.positions).toHaveLength(1);
+    }
+  });
+
+  test("retains supplied acquisition dates through resync, persistence, holding age and portfolio exports", async () => {
+    const persistence = new AppPersistence(":memory:");
+    const tickerRepository = new TickerRepository(persistence.tickers);
+    const adapter = createDemoBroker();
+    const portfolioId = "broker:demo-broker:ACC-1";
+    const column = { id: "held", label: "HELD", width: 8, align: "right" as const };
+    const now = Date.UTC(2026, 8, 12, 12);
+    const context = { activeTab: portfolioId, baseCurrency: "USD", exchangeRates: new Map([["USD", 1]]), now };
+    let config = { ...createDefaultConfig("/unused-acquisition-date"), portfolios: [], brokerInstances: [createBrokerInstance()] };
+    try {
+      for (const [shares, avgCost, dateAcquired, held] of [
+        [10, 100, "2020-01-02", "6.7y"],
+        [20, 50, "2020-01-02", "6.7y"],
+        [20, 50, undefined, "—"],
+        [20, 50, "not-a-date", "—"],
+      ] as const) {
+        adapter.importPositions = async () => [{ ticker: "AAPL", exchange: "NASDAQ", accountId: "ACC-1",
+          shares, avgCost, currency: "USD", dateAcquired }];
+        const synced = await syncBrokerInstance({ config, instanceId: "demo-broker", brokers: new Map([["demo", adapter]]), tickerRepository });
+        config = synced.config as typeof config;
+        const reloaded = (await tickerRepository.loadTicker("AAPL"))!;
+        expect(reloaded.metadata.positions).toHaveLength(1);
+        expect(reloaded.metadata.positions[0]).toMatchObject({ shares, avgCost });
+        expect(reloaded.metadata.positions[0]!.dateAcquired).toBe(dateAcquired);
+        expect(getColumnValue(column, reloaded, undefined, context).text).toBe(held);
+        expect(getSortValue(column, reloaded, undefined, context)).toBe(held === "—" ? null : 2445);
+        let exported: CliResult | undefined;
+        await showCollection(portfolioId, {
+          cliOptions: { ...DEFAULT_CLI_OPTIONS, format: "json" },
+          printResult: (result) => { exported = result; },
+          initMarketData: async () => ({ config, persistence: { close() {} }, store: tickerRepository,
+            dataProvider: createTestDataProvider({ getQuote: async () => ({ symbol: "AAPL", price: 60,
+              currency: "USD", change: 0, changePercent: 0, previousClose: 60, lastUpdated: now }) }) }),
+          fail: (message) => { throw new Error(message); },
+        } as unknown as CliCommandContext);
+        expect((exported?.data as Array<{ dateAcquired: string | null }>)[0]!.dateAcquired).toBe(dateAcquired ?? null);
+      }
+    } finally {
+      persistence.close();
+    }
+  });
+
   test("creates broker portfolios and imports positions into local tickers", async () => {
     const config = {
       ...createDefaultConfig("/tmp/gloomberb-sync-broker-instance"),

package/src/capabilities/factories.ts

@@ -1,4 +1,5 @@
 import type { AssetDataProvider } from "../types/data-provider";
+import { quoteMetadataFromQuote } from "../market-data/quotes/metadata";
 import type { NewsDataProvider } from "../types/capability-route-source";
 import {
   chartSeriesCatalogOutputSchema,
@@ -34,11 +35,14 @@ export function assetDataProvider(provider: AssetDataProvider): AssetDataCapabil
     provider,
     operations: {
       canProvide: op((input: any) => provider.canProvide?.(input.ticker, input.exchange, input.context) ?? true, "query"),
+      primaryMarketSourceName: op(() => provider.primaryMarketSourceName?.() ?? provider.name, "query"),
       getCachedFinancialsForTargets: op((input: any) => provider.getCachedFinancialsForTargets?.(input.targets ?? [], input.options) ?? new Map()),
       getQuotesBatch: op((input: any) => provider.getQuotesBatch?.(input.targets ?? [], input.options) ?? Promise.resolve([])),
       getTickerFinancialsBatch: op((input: any) => provider.getTickerFinancialsBatch?.(input.targets ?? [], input.options) ?? Promise.resolve([])),
       getTickerFinancials: op((input: any) => provider.getTickerFinancials(input.ticker, input.exchange, input.context)),
       getQuote: op((input: any) => provider.getQuote(input.ticker, input.exchange, input.context)),
+      getQuoteMetadata: op((input: any) => provider.getQuoteMetadata?.(input.ticker, input.exchange, input.context)
+        ?? provider.getQuote(input.ticker, input.exchange, input.context).then(quoteMetadataFromQuote)),
       getExchangeRate: op((input: any) => provider.getExchangeRate(input.fromCurrency)),
       search: op((input: any) => provider.search(input.query, input.context), "query"),
       getSecFilings: op((input: any) => {

package/src/capabilities/index.ts

@@ -2,4 +2,5 @@ export * from "./types";
 export * from "./registry";
 export * from "./factories";
 export * from "./service-capabilities";
+export * from "./stream-client";
 export * from "./chart-series";

package/src/capabilities/service-capabilities.ts

@@ -1,8 +1,6 @@
 import type { BrokerConnectionStatus } from "../types/broker";
 import type { QuoteSubscriptionTarget } from "../types/data-provider";
 import type { Quote } from "../types/financials";
-import type { AiAuthProgressEvent } from "../plugins/builtin/ai/runner";
-import type { AiAgentHistoryMessage } from "../plugins/builtin/ai/agent-history";
 
 export const BROKER_CAPABILITY_ID = "broker.core";
 export const NOTES_FILES_CAPABILITY_ID = "notes.files";
@@ -22,9 +20,51 @@ export type BrokerQuoteEvent = {
 
 export type BrokerRemoteEvent = BrokerStatusEvent | BrokerQuoteEvent;
 
+/**
+ * What an AI runtime reports while it signs an account in.
+ *
+ * The runtime itself is a plugin's business: which providers exist, how they
+ * authenticate, and what a run costs all change faster than the app releases.
+ * The wire shape is the app's, because the desktop view and the Bun process
+ * have to agree on it before either of them knows which plugin is on the
+ * other end.
+ */
+export type AiAuthProgressEvent =
+  | {
+      type: "info";
+      message: string;
+      links?: readonly { url: string; label?: string }[];
+    }
+  | {
+      type: "auth_url";
+      url: string;
+      instructions?: string;
+    }
+  | {
+      type: "device_code";
+      userCode: string;
+      verificationUri: string;
+      intervalSeconds?: number;
+      expiresInSeconds?: number;
+    }
+  | {
+      type: "progress";
+      message: string;
+    };
+
+/**
+ * One turn of an agent transcript, carried back so a thread survives a restart.
+ * Only the discriminator is fixed here; the runtime that produced it owns the
+ * rest and validates it on the way in.
+ */
+export interface AiRunnerAgentMessage {
+  role: string;
+  [key: string]: unknown;
+}
+
 export type AiRunnerEvent =
   | { kind: "chunk"; output: string }
-  | { kind: "done"; output: string; agentMessages?: AiAgentHistoryMessage[] }
+  | { kind: "done"; output: string; agentMessages?: AiRunnerAgentMessage[] }
   | { kind: "cancelled" }
   | { kind: "error"; error: string }
   | { kind: "account-auth"; event: AiAuthProgressEvent }

package/src/capabilities/stream-client.ts

@@ -0,0 +1,39 @@
+/**
+ * Streaming capability calls from a renderer that does not own the capability.
+ *
+ * `CapabilityInvoker` covers the request/response half: ask, get an answer.
+ * A capability that emits as it works (a model writing a token at a time, a
+ * sign-in reporting a device code) needs the other half, and on the desktop
+ * that crosses a process boundary: panes render in the view, while the
+ * capability runs in the Bun process with the credentials and the sockets.
+ *
+ * The renderer installs the client at startup, the same way it installs the
+ * broker remote client. Elsewhere there is nothing to install: the terminal
+ * runs both halves in one process, and the hosted web app has no Bun process
+ * at all, so a plugin that finds no client here reports its service as
+ * unavailable rather than pretending.
+ */
+
+export interface CapabilityStreamSubscription {
+  capabilityId: string;
+  operationId: string;
+  payload: unknown;
+  onEvent: (event: unknown) => void;
+  onError?: (error: unknown) => void;
+}
+
+export interface CapabilityStreamClient {
+  invoke<T = unknown>(capabilityId: string, operationId: string, payload: unknown): Promise<T>;
+  /** Returns the unsubscribe function; calling it ends the stream on the host side too. */
+  subscribe(subscription: CapabilityStreamSubscription): () => void;
+}
+
+let capabilityStreamClient: CapabilityStreamClient | null = null;
+
+export function setCapabilityStreamClient(client: CapabilityStreamClient | null): void {
+  capabilityStreamClient = client;
+}
+
+export function getCapabilityStreamClient(): CapabilityStreamClient | null {
+  return capabilityStreamClient;
+}

package/src/cli/base-converter.test.ts

@@ -0,0 +1,16 @@
+import { expect, test } from "bun:test";
+import { createBaseConverter } from "./base-converter";
+
+test("CLI conversion preserves missing and invalid FX instead of valuing at parity", async () => {
+  const convert = createBaseConverter({ getExchangeRate: async (currency) => {
+    if (currency === "EUR") return 1.25;
+    if (currency === "JPY") throw new Error("FX unavailable");
+    return 0;
+  } }, "EUR");
+  expect(await convert(100, "USD")).toBe(80);
+  expect(await convert(100, "EUR")).toBe(100);
+  expect(await convert(100, "JPY")).toBeNaN();
+  expect(await convert(100, "GBP")).toBeNaN();
+  const missingBase = createBaseConverter({ getExchangeRate: async () => Number.NaN }, "GBP");
+  expect(await missingBase(100, "USD")).toBeNaN();
+});

package/src/cli/base-converter.ts

@@ -9,10 +9,11 @@ export function createBaseConverter(dataProvider: Pick<DataProvider, "getExchang
     if (cached != null) return cached;
     try {
       const rate = await dataProvider.getExchangeRate(normalizedCurrency);
-      rateCache.set(normalizedCurrency, rate);
-      return rate;
+      const validRate = Number.isFinite(rate) && rate > 0 ? rate : Number.NaN;
+      rateCache.set(normalizedCurrency, validRate);
+      return validRate;
     } catch {
-      return 1;
+      return Number.NaN;
     }
   };
 
@@ -25,7 +26,7 @@ export function createBaseConverter(dataProvider: Pick<DataProvider, "getExchang
       getRate(normalizedFrom),
       getRate(normalizedBase),
     ]);
-    if (baseRate === 0) return value;
+    if (!Number.isFinite(fromRate) || !Number.isFinite(baseRate) || baseRate <= 0) return Number.NaN;
     return (value * fromRate) / baseRate;
   };
 }