gloomberb 0.9.2 → 0.9.4

package/README.md

@@ -60,6 +60,7 @@ Open command mode with `Ctrl+P`, then type a command. Press `` ` `` to open tick
 | `TOP` | Ranked market stories |
 | `MOST` | Market movers |
 | `PF` | Portfolios and watchlists |
+| `KELLY AAPL` | Position sizing |
 | `HELP` | Full in-app shortcut list |
 
 ## What It Does
@@ -70,22 +71,43 @@ Open command mode with `Ctrl+P`, then type a command. Press `` ` `` to open tick
 
 ## CLI
 
-Running `gloomberb` with no arguments launches the terminal UI. Use `gloomberb help` to see the full command list.
+Running `gloomberb` with no arguments launches the terminal UI. Normal commands run through a headless CLI path; use `gloomberb launch-ui` when a script should explicitly open the UI.
+
+Human-readable output is the default. Automation can opt into structured output with `--json`, `--csv`, or `--ndjson`. JSON output favors the richest fetched model available and includes display-column metadata when a command has table columns; CSV and NDJSON use the command's tabular row view. Common global flags include `--limit`, `--refresh`, `--quiet`, `--no-color`, `--dry-run`, and `--yes`.
 
 | Command | Use |
 |---------|-----|
 | `gloomberb` | Launch the terminal UI |
+| `gloomberb launch-ui` | Explicitly launch the terminal UI |
 | `gloomberb help` | Show all CLI commands |
-| `gloomberb search <query>` | Search tickers and company names |
+| `gloomberb api list|get|invoke|subscribe` | Inspect and call plugin capabilities directly |
+| `gloomberb quote <symbols>` | Fetch current quotes |
+| `gloomberb search <query>` / `provider-search <query>` | Search tickers and provider symbols |
 | `gloomberb ticker <symbol>` | Show quote, ownership, and financials |
+| `gloomberb history|financials|fundamentals|options <symbol>` | Fetch research data |
+| `gloomberb news|filings|holders|insider|13f|analyst|events|valuation <symbol>` | Fetch company research feeds |
+| `gloomberb movers|indices|sectors|fx|fear-greed|earnings` | Fetch market overview data |
+| `gloomberb econ|fred|yield-curve` | Fetch macro data |
+| `gloomberb compare|correlation|relationship <symbols>` | Compare securities |
 | `gloomberb portfolio [action]` | Manage manual portfolios |
 | `gloomberb watchlist [action]` | Manage watchlists |
+| `gloomberb notes|alerts [action]` | Manage local notes and alerts |
+| `gloomberb broker|ibkr [action]` | Inspect broker integrations; trading actions require explicit account/profile and `--yes` |
+| `gloomberb ai providers|ask|screen` | Use configured AI providers and screeners |
+| `gloomberb rss fetch <url>` | Fetch an RSS feed |
+| `gloomberb buildout|congress|substack|x-feed|tweets` | Access cloud and social data sources when an existing session is available |
+| `gloomberb provider status` | Inspect enabled data providers |
+| `gloomberb config|cache|plugin|layout|pane|debug|doctor|version|changelog` | Inspect and manage local app state |
+| `gloomberb fn [...]` | Run a pane-backed report command |
+| `gloomberb shot [...]` | Capture a pane-backed screenshot |
 | `gloomberb predictions [...]` | Launch Prediction Markets |
 | `gloomberb plugins` | List installed plugins |
 | `gloomberb install <user/repo>` | Install a plugin from GitHub |
 | `gloomberb remove <name>` | Remove an installed plugin |
 | `gloomberb update [name]` | Update plugins |
 
+Commands that need a signed-in cloud session may return `auth_required`; sign-in, account management, and chat workflows are still handled in the app UI for now.
+
 ## Plugins
 
 Everything from the portfolio list to broker integrations is a plugin. Plugins can add panes, tabs, columns, command bar commands, CLI commands, status bar widgets, and data providers.

package/bin/gloomberb

@@ -1,3 +1,3 @@
 #!/usr/bin/env bun
 
-import "../src/index.tsx"
+import "../src/cli/entry.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Market research and portfolio tracker for the terminal",
   "module": "src/index.tsx",
   "type": "module",

package/src/app/runtime/desktop-menu.ts

@@ -54,7 +54,11 @@ export function useDesktopApplicationMenuRuntime({
           break;
         case "layout-gridlock": {
           const { width, height } = pluginRegistry.getTermSizeFn();
-          pluginRegistry.updateLayoutFn(gridlockAllPanes(stateRef.current.config.layout, { x: 0, y: 0, width, height }));
+          pluginRegistry.updateLayoutFn(gridlockAllPanes(
+            stateRef.current.config.layout,
+            { x: 0, y: 0, width, height },
+            pluginRegistry.panes,
+          ));
           notifyGridlockComplete(pluginRegistry.notify.bind(pluginRegistry), () => {
             dispatch({ type: "UNDO_LAYOUT" });
           });

package/src/app/runtime/ticker-refresh.ts

@@ -164,7 +164,10 @@ export function useTickerRefreshRuntime({
           dispatch({ type: "SET_REFRESHING", symbol, refreshing: true });
         }
         try {
-          const entries = await marketData.loadSnapshotsBatch(instrumentEntries.map((entry) => entry.instrument));
+          const entries = await marketData.loadSnapshotsBatch(
+            instrumentEntries.map((entry) => entry.instrument),
+            { forceRefresh: true },
+          );
           entries.forEach((entry, index) => {
             const ticker = instrumentEntries[index]?.ticker;
             const data = entry.data ?? entry.lastGoodData;

package/src/app.tsx

@@ -14,6 +14,7 @@ import { Header } from "./components/layout/header";
 import { StatusBar } from "./components/layout/status-bar";
 import { Shell } from "./components/layout/shell";
 import { DetachedPaneShell } from "./components/layout/detached-pane-shell";
+import { TransientLayoutProvider } from "./components/layout/transient-layout";
 import { CommandBar } from "./components/command-bar/surface";
 import { OnboardingWizard } from "./components/onboarding/onboarding-wizard";
 import { useDialog } from "./ui/dialog";
@@ -59,7 +60,16 @@ interface AppInnerProps {
 function ThemedAppRoot({ children }: { children: ReactNode }) {
   const themeColors = useThemeColors();
   return (
-    <Box flexDirection="column" flexGrow={1} backgroundColor={themeColors.bg}>
+    <Box
+      flexDirection="column"
+      flexGrow={1}
+      flexShrink={1}
+      flexBasis={0}
+      minWidth={0}
+      minHeight={0}
+      overflow="hidden"
+      backgroundColor={themeColors.bg}
+    >
       {children}
     </Box>
   );
@@ -293,13 +303,15 @@ function AppInner({
     <ContextMenuProvider pluginRegistry={pluginRegistry}>
       <ThemedAppRoot>
         <Header />
-        <Shell
-          pluginRegistry={pluginRegistry}
-          desktopWindowBridge={desktopWindowBridge}
-          desktopDockPreview={desktopDockPreview}
-          commandBarNativeOccluder={commandBarNativeOccluder}
-        />
-        <StatusBar />
+        <TransientLayoutProvider>
+          <Shell
+            pluginRegistry={pluginRegistry}
+            desktopWindowBridge={desktopWindowBridge}
+            desktopDockPreview={desktopDockPreview}
+            commandBarNativeOccluder={commandBarNativeOccluder}
+          />
+          <StatusBar />
+        </TransientLayoutProvider>
         {state.commandBarOpen && (
           <CommandBar
             dataProvider={dataProvider}

package/src/brokers/account-cache.ts

@@ -124,7 +124,7 @@ export function loadPersistedBrokerAccountMap(
 
   for (const instance of brokerInstances) {
     const broker = brokers.get(instance.brokerType);
-    if (!broker?.listAccounts) continue;
+    if (!broker?.listAccounts && !broker?.importPortfolioSnapshot) continue;
     const accounts = loadPersistedBrokerAccounts(resources, instance, broker);
     if (!accounts || accounts.length === 0) continue;
     accountMap[instance.id] = accounts;

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

@@ -2,6 +2,8 @@ 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 { AppPersistence } from "../data/app-persistence";
+import { loadPersistedBrokerAccounts, persistBrokerAccounts } from "./account-cache";
 import {
   restoreBrokerPortfoliosFromTickerPositions,
   syncBrokerInstance,
@@ -164,6 +166,111 @@ describe("syncBrokerInstance", () => {
     ]);
   });
 
+  test("imports account and position data from one broker portfolio snapshot", async () => {
+    const instance = createBrokerInstance();
+    const config = {
+      ...createDefaultConfig("/tmp/gloomberb-sync-broker-snapshot"),
+      portfolios: [],
+      brokerInstances: [instance],
+    };
+    const tickerRepository = createTickerRepository();
+    const persistence = new AppPersistence(":memory:");
+    let listAccountsCalled = false;
+    let importPositionsCalled = false;
+    const broker: BrokerAdapter = {
+      ...createDemoBroker(),
+      listAccounts: async () => {
+        listAccountsCalled = true;
+        return [];
+      },
+      importPositions: async () => {
+        importPositionsCalled = true;
+        return [];
+      },
+      importPortfolioSnapshot: async () => ({
+        accounts: [{
+          accountId: "ACC-1",
+          name: "Snapshot Account",
+          currency: "USD",
+          netLiquidation: 125_000,
+          grossPositionValue: 175_000,
+          totalCashValue: -50_000,
+        }],
+        positions: [{
+          ticker: "AAPL",
+          exchange: "NASDAQ",
+          shares: 12,
+          avgCost: 180,
+          currency: "USD",
+          accountId: "ACC-1",
+          name: "Apple Inc.",
+          assetCategory: "STK",
+        }],
+      }),
+    };
+
+    try {
+      const result = await syncBrokerInstance({
+        config,
+        instanceId: "demo-broker",
+        brokers: new Map([["demo", broker]]),
+        tickerRepository: tickerRepository as any,
+        resources: persistence.resources,
+      });
+
+      expect(listAccountsCalled).toBe(false);
+      expect(importPositionsCalled).toBe(false);
+      expect(result.brokerAccounts[0]?.netLiquidation).toBe(125_000);
+      expect(result.positions).toHaveLength(1);
+      expect(loadPersistedBrokerAccounts(persistence.resources, instance, broker)).toEqual(result.brokerAccounts);
+    } finally {
+      persistence.close();
+    }
+  });
+
+  test("preserves the last account snapshot when a broker portfolio snapshot fails", async () => {
+    const instance = createBrokerInstance();
+    const config = {
+      ...createDefaultConfig("/tmp/gloomberb-sync-broker-snapshot-failure"),
+      portfolios: [],
+      brokerInstances: [instance],
+    };
+    const tickerRepository = createTickerRepository();
+    const persistence = new AppPersistence(":memory:");
+    const broker: BrokerAdapter = {
+      ...createDemoBroker(),
+      importPortfolioSnapshot: async () => {
+        throw new Error("account snapshot unavailable");
+      },
+    };
+
+    try {
+      persistBrokerAccounts(persistence.resources, instance, broker, [{
+        accountId: "ACC-1",
+        name: "Stale Account",
+        currency: "USD",
+        netLiquidation: 99_000,
+      }]);
+
+      await expect(syncBrokerInstance({
+        config,
+        instanceId: "demo-broker",
+        brokers: new Map([["demo", broker]]),
+        tickerRepository: tickerRepository as any,
+        resources: persistence.resources,
+      })).rejects.toThrow("account snapshot unavailable");
+
+      expect(loadPersistedBrokerAccounts(persistence.resources, instance, broker)).toEqual([{
+        accountId: "ACC-1",
+        name: "Stale Account",
+        currency: "USD",
+        netLiquidation: 99_000,
+      }]);
+    } finally {
+      persistence.close();
+    }
+  });
+
   test("preserves broker portfolios across sequential profile syncs", async () => {
     const config = {
       ...createDefaultConfig("/tmp/gloomberb-sync-broker-instances"),

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

@@ -131,17 +131,30 @@ export async function syncBrokerInstance({
   const tickers = await loadTickerMap(tickerRepository, existingTickers);
 
   let brokerAccounts: BrokerAccount[] = [];
-  if (broker.listAccounts) {
-    try {
-      brokerAccounts = await broker.listAccounts(instance);
-      if (resources) {
-        try {
-          persistBrokerAccounts(resources, instance, broker, brokerAccounts);
-        } catch {}
+  let positions: BrokerPosition[];
+  if (broker.importPortfolioSnapshot) {
+    const snapshot = await broker.importPortfolioSnapshot(instance);
+    brokerAccounts = snapshot.accounts;
+    positions = snapshot.positions;
+    if (resources) {
+      try {
+        persistBrokerAccounts(resources, instance, broker, brokerAccounts);
+      } catch {}
+    }
+  } else {
+    if (broker.listAccounts) {
+      try {
+        brokerAccounts = await broker.listAccounts(instance);
+        if (resources) {
+          try {
+            persistBrokerAccounts(resources, instance, broker, brokerAccounts);
+          } catch {}
+        }
+      } catch (error) {
+        throw error;
       }
-    } catch {
-      brokerAccounts = [];
     }
+    positions = await broker.importPositions(instance);
   }
 
   const accountMetadata = new Map(
@@ -154,7 +167,6 @@ export async function syncBrokerInstance({
     ]),
   );
 
-  const positions = await broker.importPositions(instance);
   const syncedAt = Date.now();
 
   let nextConfig = config;

package/src/capabilities/registry.ts

@@ -58,6 +58,7 @@ export class CapabilityRegistry {
           id,
           kind: operation.kind,
           rendererSafe: operation.rendererSafe === true,
+          ...operation.cli,
         }));
       return {
         id: capability.id,

package/src/capabilities/types.ts

@@ -3,6 +3,7 @@ import type { AssetDataProvider } from "../types/data-provider";
 import type { NewsDataProvider } from "../types/capability-route-source";
 
 type CapabilityOperationKind = "read" | "query" | "action" | "stream";
+type CapabilitySideEffectLevel = "none" | "local-write" | "network-write" | "external-trade" | "external-side-effect";
 
 type CapabilityKind =
   | "asset-data"
@@ -20,9 +21,22 @@ interface CapabilityHandlerContext {
 
 type CapabilityStreamEmit<T = unknown> = (event: T) => void;
 
+export interface CapabilityOperationCliManifest {
+  summary?: string;
+  inputShape?: string;
+  outputShape?: string;
+  examples?: string[];
+  sideEffectLevel?: CapabilitySideEffectLevel;
+  requirements?: string[];
+  batch?: boolean;
+  formats?: Array<"text" | "json" | "csv" | "ndjson">;
+  safety?: string[];
+}
+
 export interface CapabilityOperation<I = unknown, O = unknown, E = unknown> {
   kind: CapabilityOperationKind;
   rendererSafe?: boolean;
+  cli?: CapabilityOperationCliManifest;
   input?: CapabilitySchema<I>;
   output?: CapabilitySchema<O>;
   cachePolicy?: CachePolicyMap[keyof CachePolicyMap];
@@ -55,6 +69,15 @@ export interface CapabilityOperationManifest {
   id: string;
   kind: CapabilityOperationKind;
   rendererSafe: boolean;
+  summary?: string;
+  inputShape?: string;
+  outputShape?: string;
+  examples?: string[];
+  sideEffectLevel?: CapabilitySideEffectLevel;
+  requirements?: string[];
+  batch?: boolean;
+  formats?: Array<"text" | "json" | "csv" | "ndjson">;
+  safety?: string[];
 }
 
 export interface CapabilityManifest {

package/src/cli/commands/api.ts

@@ -0,0 +1,119 @@
+import type { CliCommandDef } from "../../types/plugin";
+import { parseJsonPayload, requireArg, takeOption } from "./command-utils";
+
+function splitOperationTarget(target: string): { capabilityId: string; operationId: string } {
+  const separator = target.lastIndexOf(".");
+  if (separator <= 0 || separator === target.length - 1) {
+    throw new Error("Use <capability-id>.<operation-id>.");
+  }
+  return {
+    capabilityId: target.slice(0, separator),
+    operationId: target.slice(separator + 1),
+  };
+}
+
+function parseOperationTarget(target: string, ctx: Parameters<CliCommandDef["execute"]>[1]) {
+  try {
+    return splitOperationTarget(target);
+  } catch (error) {
+    ctx.fail("Invalid capability operation target.", error instanceof Error ? error.message : String(error));
+  }
+}
+
+export const apiCliCommand: CliCommandDef = {
+  name: "api",
+  description: "List, inspect, invoke, or subscribe to plugin capabilities",
+  help: {
+    usage: [
+      "api list [--kind kind]",
+      "api get <capability-id>",
+      "api invoke <capability.operation> [json-payload]",
+      "api subscribe <capability.operation> [json-payload] [--limit n]",
+    ],
+  },
+  execute: async (rawArgs, ctx) => {
+    const action = rawArgs[0] ?? "list";
+    const args = rawArgs.slice(1);
+    const services = await ctx.initServices();
+
+    try {
+      if (action === "list") {
+        const kind = takeOption(args, "--kind");
+        const manifests = services.services.pluginRegistry.capabilities
+          .manifests()
+          .filter((manifest) => !kind || manifest.kind === kind);
+        ctx.printResult({ data: manifests }, {
+          rows: (data) => data.map((manifest) => ({
+            id: manifest.id,
+            kind: manifest.kind,
+            name: manifest.name,
+            operations: manifest.operations.map((operation) => operation.id).join(", "),
+          })),
+          columns: [
+            { key: "id", header: "Capability" },
+            { key: "kind", header: "Kind" },
+            { key: "name", header: "Name" },
+            { key: "operations", header: "Operations" },
+          ],
+        });
+        return;
+      }
+
+      if (action === "get") {
+        const capabilityId = requireArg(args[0], "Usage: gloomberb api get <capability-id>", ctx);
+        const manifest = services.services.pluginRegistry.capabilities
+          .manifests()
+          .find((entry) => entry.id === capabilityId);
+        if (!manifest) ctx.fail(`Capability "${capabilityId}" is not available.`);
+        ctx.printResult({ data: manifest });
+        return;
+      }
+
+      if (action === "invoke") {
+        const target = requireArg(args[0], "Usage: gloomberb api invoke <capability.operation> [json-payload]", ctx);
+        const operationTarget = parseOperationTarget(target, ctx);
+        const payload = parseJsonPayload(args[1], ctx);
+        const data = await services.services.pluginRegistry.capabilities.invoke(
+          operationTarget.capabilityId,
+          operationTarget.operationId,
+          payload,
+        );
+        ctx.printResult({ data });
+        return;
+      }
+
+      if (action === "subscribe") {
+        const target = requireArg(args[0], "Usage: gloomberb api subscribe <capability.operation> [json-payload] [--limit n]", ctx);
+        const operationTarget = parseOperationTarget(target, ctx);
+        const limit = ctx.cliOptions.limit ?? 10;
+        const payload = parseJsonPayload(args[1], ctx);
+        let count = 0;
+        let subscriptionId: string | null = null;
+        await new Promise<void>(async (resolve, reject) => {
+          try {
+            subscriptionId = await services.services.pluginRegistry.capabilities.subscribe(
+              operationTarget.capabilityId,
+              operationTarget.operationId,
+              payload,
+              (event) => {
+                count += 1;
+                ctx.printResult({ data: event });
+                if (count >= limit && subscriptionId) {
+                  services.services.pluginRegistry.capabilities.unsubscribe(subscriptionId);
+                  resolve();
+                }
+              },
+            );
+          } catch (error) {
+            reject(error);
+          }
+        });
+        return;
+      }
+
+      ctx.fail("Usage: gloomberb api list|get|invoke|subscribe");
+    } finally {
+      services.destroy();
+    }
+  },
+};

package/src/cli/commands/automation.ts

@@ -0,0 +1,173 @@
+import { detectProviders, getAiProvider } from "../../plugins/builtin/ai/providers";
+import { runAiPrompt } from "../../plugins/builtin/ai/runner";
+import { createRssNewsCapability } from "../../plugins/builtin/news/wire/rss/source";
+import type { CliCommandDef } from "../../types/plugin";
+import { requireArg, takeOption } from "./command-utils";
+
+function deferredResult(command: string, code: "auth_required" | "not_implemented", message: string) {
+  return {
+    command,
+    status: code,
+    code,
+    message,
+  };
+}
+
+export const brokerCliCommand: CliCommandDef = {
+  name: "broker",
+  aliases: ["brokers"],
+  description: "Inspect broker profiles and guarded broker operations",
+  help: { usage: ["broker list", "broker status", "broker add|edit|remove|connect|sync"] },
+  execute: async (args, ctx) => {
+    const action = args[0] ?? "list";
+    const services = await ctx.initServices();
+    try {
+      if (action === "list" || action === "status") {
+        const rows = services.config.brokerInstances.map((instance) => ({
+          id: instance.id,
+          type: instance.brokerType,
+          label: instance.label,
+          enabled: instance.enabled !== false,
+          connectionMode: instance.connectionMode ?? "",
+          lastSyncedAt: instance.lastSyncedAt ? new Date(instance.lastSyncedAt).toISOString() : "",
+        }));
+        ctx.printResult({ data: rows });
+        return;
+      }
+
+      ctx.printResult({
+        data: deferredResult("broker", "not_implemented", "Broker mutation and connection commands need shared non-UI broker service extraction before they can safely run headless."),
+      });
+    } finally {
+      services.destroy();
+    }
+  },
+};
+
+export const ibkrCliCommand: CliCommandDef = {
+  name: "ibkr",
+  description: "Guarded IBKR account, order preview, and order action commands",
+  help: { usage: ["ibkr accounts|positions|orders|preview|place|cancel"] },
+  execute: async (args, ctx) => {
+    const action = args[0] ?? "status";
+    const profile = takeOption(args, "--profile");
+    const account = takeOption(args, "--account");
+    if ((action === "place" || action === "cancel") && (!profile || !account || !ctx.cliOptions.yes)) {
+      ctx.fail(`ibkr ${action} requires --profile, --account, and --yes.`);
+    }
+    const services = await ctx.initServices();
+    try {
+      const ibkrProfiles = services.config.brokerInstances.filter((instance) => instance.brokerType === "ibkr");
+      if (action === "accounts" || action === "status") {
+        ctx.printResult({ data: ibkrProfiles.map((instance) => ({
+          id: instance.id,
+          label: instance.label,
+          enabled: instance.enabled !== false,
+          connectionMode: instance.connectionMode ?? "",
+          lastSyncedAt: instance.lastSyncedAt ? new Date(instance.lastSyncedAt).toISOString() : "",
+        })) });
+        return;
+      }
+      ctx.printResult({
+        data: {
+          ...deferredResult("ibkr", "not_implemented", "IBKR trading commands are registered with safety gates, but headless order/account service extraction is still required."),
+          action,
+          profile: profile ?? null,
+          account: account ?? null,
+          dryRun: ctx.cliOptions.dryRun,
+          confirmed: ctx.cliOptions.yes,
+        },
+      });
+    } finally {
+      services.destroy();
+    }
+  },
+};
+
+export const aiCliCommand: CliCommandDef = {
+  name: "ai",
+  description: "Inspect AI providers and run guarded headless AI prompts",
+  help: { usage: ["ai providers", "ai ask [--provider id] <prompt>", "ai screen list|show|delete|refresh|export"] },
+  execute: async (args, ctx) => {
+    const action = args[0] ?? "providers";
+    if (action === "providers") {
+      ctx.printResult({ data: detectProviders().map((provider) => ({
+        id: provider.id,
+        name: provider.name,
+        command: provider.command,
+        available: provider.available,
+      })) });
+      return;
+    }
+    if (action === "ask") {
+      const rawArgs = args.slice(1);
+      const providerId = takeOption(rawArgs, "--provider") ?? detectProviders().find((provider) => provider.available)?.id;
+      const provider = getAiProvider(providerId);
+      if (!provider) ctx.fail("Unknown AI provider.");
+      const selectedProvider = provider;
+      if (!selectedProvider.available) ctx.fail(`${selectedProvider.name} is not installed or not available in PATH.`);
+      const prompt = rawArgs.join(" ").trim();
+      if (!prompt) ctx.fail("Usage: gloomberb ai ask [--provider id] <prompt>");
+      const controller = runAiPrompt({ provider: selectedProvider, prompt, cwd: process.cwd() });
+      const text = await controller.done;
+      ctx.printResult({ data: { provider: selectedProvider.id, text } });
+      return;
+    }
+    if (action === "screen") {
+      ctx.printResult({
+        data: deferredResult("ai screen", "not_implemented", "AI screener tabs are still pane-state backed; expose them through a shared non-UI screener store before headless mutation."),
+      });
+      return;
+    }
+    ctx.fail("Usage: gloomberb ai providers|ask|screen");
+  },
+};
+
+export const rssCliCommand: CliCommandDef = {
+  name: "rss",
+  description: "Fetch an RSS feed as news rows",
+  help: { usage: ["rss fetch <url> [--name label]"] },
+  execute: async (args, ctx) => {
+    const action = args[0] ?? "fetch";
+    if (action !== "fetch") ctx.fail("Usage: gloomberb rss fetch <url> [--name label]");
+    const rawArgs = args.slice(1);
+    const name = takeOption(rawArgs, "--name") ?? "RSS";
+    const url = requireArg(rawArgs[0], "Usage: gloomberb rss fetch <url> [--name label]", ctx);
+    const capability = createRssNewsCapability([{
+      id: "cli-feed",
+      url,
+      name,
+      category: "cli",
+      authority: 50,
+      enabled: true,
+    }]);
+    const articles = await capability.provider.fetchNews({ feed: "latest", limit: ctx.cliOptions.limit ?? 20 });
+    ctx.printResult({ data: articles.map((article) => ({
+      title: article.title,
+      source: article.source,
+      publishedAt: article.publishedAt.toISOString(),
+      url: article.url,
+      summary: article.summary ?? "",
+    })) });
+  },
+};
+
+function cloudCommand(name: string, description: string): CliCommandDef {
+  return {
+    name,
+    description,
+    execute: (_args, ctx) => {
+      ctx.printResult({
+        data: deferredResult(name, "auth_required", "This command needs an existing cloud/session token. New auth/account/chat CLI workflows are deferred in this pass."),
+      });
+    },
+  };
+}
+
+export const cloudCliCommands: CliCommandDef[] = [
+  cloudCommand("buildout", "Fetch Buildout company data through an existing cloud session"),
+  cloudCommand("congress", "Fetch congressional trade data through an existing cloud session"),
+  cloudCommand("substack", "Fetch Substack reader data through an existing session"),
+  cloudCommand("x-feed", "Fetch X/Twitter feed data through an existing cloud session"),
+  cloudCommand("tweets", "Alias for x-feed"),
+];