gloomberb 0.13.2 → 0.14.0

package/src/cli/pane-functions/cloud-session.ts

@@ -8,9 +8,18 @@ interface PersistedCloudSession {
   sessionToken?: unknown;
 }
 
+/**
+ * A container has no local plugin state, so a bot or a CI job has no way to
+ * reach Pro gated panes. `GLOOMBERB_SESSION_TOKEN` gives headless callers the
+ * same session the desktop app persists after signing in, and it wins over the
+ * stored one so a service account can be pointed somewhere else without
+ * touching the user's own state.
+ */
 export function resolvePersistedCloudSessionToken(
   context: Pick<MarketContext, "persistence">,
 ): string | null {
+  const fromEnv = process.env.GLOOMBERB_SESSION_TOKEN?.trim();
+  if (fromEnv) return fromEnv;
   for (const key of CLOUD_SESSION_KEYS) {
     const value = context.persistence.pluginState.get<PersistedCloudSession>(
       CLOUD_PLUGIN_ID,

package/src/cli/pane-functions/data.ts

@@ -51,12 +51,6 @@ export async function withShotPriceHistory(
   }
 }
 
-export function requireSymbol(resolved: ResolvedPaneFunction, rawArg: string): string {
-  const symbol = resolved.createOptions?.symbol ?? normalizeTickerInput(null, cleanTickerInput(rawArg));
-  if (!symbol) throw new Error(`Usage: gloomberb fn ${resolved.token} <symbol>`);
-  return symbol;
-}
-
 export function isFinancialAnalysisFunction(resolved: ResolvedPaneFunction): boolean {
   if (resolved.pane.id === FINANCIAL_ANALYSIS_PANE_ID) return true;
   if (resolved.template?.id === FINANCIAL_ANALYSIS_TEMPLATE_ID) return true;

package/src/cli/pane-functions/discovery.test.ts

@@ -0,0 +1,36 @@
+import { expect, test } from "bun:test";
+import { createDefaultConfig } from "../../types/config";
+import type { GloomPlugin } from "../../types/plugin";
+import type { MarketContext } from "../types";
+import { createPaneCatalog } from "./discovery";
+
+const context = { config: createDefaultConfig("/tmp/discovery-test") } as MarketContext;
+
+function plugin(id: string, overrides: Partial<GloomPlugin> = {}): GloomPlugin {
+  return { id, name: id, version: "1", setup() {}, ...overrides };
+}
+
+test("failed discovery unwinds every started plugin, preserving the setup error", async () => {
+  const disposed: string[] = [];
+  const failure = new Error("setup failed");
+  await expect(createPaneCatalog(context, [
+    plugin("first", { dispose() { disposed.push("first"); } }),
+    plugin("second", {
+      setup() { throw failure; },
+      dispose() { disposed.push("second"); throw new Error("dispose failed"); },
+    }),
+    plugin("never started", { dispose() { disposed.push("never started"); } }),
+  ])).rejects.toBe(failure);
+  expect(disposed).toEqual(["second", "first"]);
+});
+
+test("destroy drains discovery once even when a disposer throws", async () => {
+  const disposed: string[] = [];
+  const catalog = await createPaneCatalog(context, [
+    plugin("first", { dispose() { disposed.push("first"); } }),
+    plugin("second", { dispose() { disposed.push("second"); throw new Error("dispose failed"); } }),
+  ]);
+  expect(() => catalog.destroy()).toThrow("dispose failed");
+  expect(() => catalog.destroy()).not.toThrow();
+  expect(disposed).toEqual(["second", "first"]);
+});

package/src/cli/pane-functions/discovery.ts

@@ -1,6 +1,8 @@
 import { ConnectionHealthRegistry } from "../../core/connection-health";
+import type { TickerRepository } from "../../data/ticker-repository";
 import type { AppConfig } from "../../types/config";
 import type { DataProvider } from "../../types/data-provider";
+import type { PersistedResourceValue } from "../../types/persistence";
 import type {
   GloomPlugin,
   GloomPluginContext,
@@ -8,8 +10,7 @@ import type {
   PaneTemplateDef,
   PluginPersistence,
 } from "../../types/plugin";
-import type { PersistedResourceValue } from "../../types/persistence";
-import type { TickerRepository } from "../../data/ticker-repository";
+import { createPluginTeamState } from "../../plugins/team-state";
 import type { MarketContext } from "../types";
 import type { PaneFunctionCatalog } from "./catalog";
 
@@ -74,7 +75,12 @@ function buildDiscoveryContext({
   const fakePersistence = createDiscoveryPluginPersistence();
   const discoveryContext: GloomPluginContext = {
     registerPane: (pane: PaneDef) => panes.set(pane.id, pane),
-    registerPaneTemplate: (template: PaneTemplateDef) => paneTemplates.set(template.id, template),
+    registerPaneTemplate: (template: PaneTemplateDef) => {
+      paneTemplates.set(template.id, template);
+      return () => {
+        if (paneTemplates.get(template.id) === template) paneTemplates.delete(template.id);
+      };
+    },
     registerCommand: () => {},
     registerCommandBarSearchProvider: () => () => {},
     registerColumn: () => {},
@@ -120,6 +126,7 @@ function buildDiscoveryContext({
       set: async () => {},
       delete: async () => {},
     },
+    teamState: createPluginTeamState("discovery"),
     createBrokerInstance: async () => {
       throw new Error("Broker creation is unavailable during CLI pane discovery.");
     },
@@ -137,6 +144,7 @@ function buildDiscoveryContext({
     pinTicker: () => {},
     navigateTicker: () => {},
     openPaneSettings: () => {},
+    sharePane: () => {},
     on: () => () => {},
     emit: () => {},
     notify: () => {},
@@ -152,24 +160,28 @@ export async function createPaneCatalog(context: MarketContext, plugins: GloomPl
     tickerRepository: context.store,
   });
 
-  for (const plugin of plugins) {
-    for (const pane of plugin.panes ?? []) panes.set(pane.id, pane);
-    for (const template of plugin.paneTemplates ?? []) paneTemplates.set(template.id, template);
-    if (plugin.setup) {
-      setupPlugins.push(plugin);
-      await plugin.setup(discoveryContext);
+  const destroy = () => {
+    let failure: unknown;
+    for (const plugin of setupPlugins.splice(0).reverse()) {
+      try { plugin.dispose?.(); } catch (error) { failure ??= error; }
     }
-  }
+    if (failure) throw failure;
+  };
 
-  return {
-    panes,
-    paneTemplates,
-    destroy() {
-      for (const plugin of setupPlugins.reverse()) {
-        plugin.dispose?.();
+  try {
+    for (const plugin of plugins) {
+      for (const pane of plugin.panes ?? []) panes.set(pane.id, pane);
+      for (const template of plugin.paneTemplates ?? []) paneTemplates.set(template.id, template);
+      if (plugin.setup) {
+        setupPlugins.push(plugin);
+        await plugin.setup(discoveryContext);
       }
-    },
-  };
+    }
+  } catch (error) {
+    try { destroy(); } catch { /* Preserve the setup error after attempting every disposer. */ }
+    throw error;
+  }
+  return { panes, paneTemplates, destroy };
 }
 
 function createDiscoveryPluginPersistence(): PluginPersistence {

package/src/cli/pane-functions/headless.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, test } from "bun:test";
 import { DEFAULT_CLI_OPTIONS } from "../options";
 import { serializeCliResult } from "../result";
+import { createDefaultConfig } from "../../types/config";
+import type { MarketContext } from "../types";
+import type { ResolvedPaneFunction } from "./resolver";
 import type {
   HeadlessBundleResult,
   HeadlessPaneDefinition,
@@ -14,6 +17,7 @@ import type {
 import { getPaneFunctionCapability, normalizeCapabilityOptions } from "./capabilities";
 import {
   buildHeadlessPaneLoadArgs,
+  buildHeadlessFunctionReport,
   renderHeadlessPaneText,
   serializeHeadlessPaneResult,
 } from "./headless";
@@ -37,6 +41,22 @@ function jsonData(
 }
 
 describe("headless pane printer", () => {
+  test("empty reports mark model-resolved inputs unavailable when the argument contains no tickers", async () => {
+    const definition: HeadlessPaneDefinition<"series"> = {
+      shape: "series", argument: { kind: "none" }, options: [],
+      load: () => ({ symbols: ["SPY"], series: [] }),
+    };
+    const report = await buildHeadlessFunctionReport({
+      headless: definition, token: "benchmark", label: "Benchmark", options: {},
+      instance: {}, capability: { id: "benchmark" },
+    } as ResolvedPaneFunction, {
+      config: createDefaultConfig("/tmp/gloomberb-headless-symbols"),
+    } as MarketContext, "");
+    expect(report.data).toMatchObject({
+      symbols: ["SPY"], unavailableSymbols: ["SPY"], empty: true, complete: false,
+    });
+  });
+
   test("renders rows as aligned text and preserves raw values in JSON", () => {
     const definition: HeadlessPaneDefinition<"rows"> = {
       shape: "rows",
@@ -173,6 +193,9 @@ describe("headless pane arguments and options", () => {
       argument: ["AAPL", "MSFT"],
       symbols: ["AAPL", "MSFT"],
     });
+    expect(buildHeadlessPaneLoadArgs(definition, "CMP", "$aapl msft, AAPL", {})).toMatchObject({
+      symbols: ["AAPL", "MSFT"],
+    });
     expect(() => buildHeadlessPaneLoadArgs(definition, "CMP", "AAPL", {}))
       .toThrow("CMP requires at least 2 symbols");
   });
@@ -245,3 +268,47 @@ describe("headless pane arguments and options", () => {
     });
   });
 });
+
+test("partial usable reports retain rows without marking their symbol wholly unavailable", async () => {
+  const definition: HeadlessPaneDefinition<"rows"> = {
+    shape: "rows", argument: { kind: "none" }, options: [],
+    load: () => ({ symbols: ["MSFT"], rows: [{ date: "2025-06-30", margin: .46 }], complete: false }),
+  };
+  const report = await buildHeadlessFunctionReport({
+    headless: definition, token: "partial", label: "Partial", options: {}, instance: {}, capability: { id: "partial" },
+  } as ResolvedPaneFunction, { config: createDefaultConfig("/tmp/gloomberb-headless-partial") } as MarketContext, "");
+  expect(report.data).toMatchObject({ rowCount: 1, empty: false, complete: false, unavailableSymbols: [], rows: [{ date: "2025-06-30", margin: .46 }] });
+});
+
+test("headless text preserves applicable coverage notices once before the exported rows", () => {
+  const text = renderHeadlessPaneText({ shape: "rows", columns: [{ key: "value", header: "Value" }] } as any,
+    { rows: [{ value: 96_571_000_000 }], metadata: { notices: ["Historical versions unavailable.", "Historical versions unavailable.", null, ""] } },
+    { symbols: ["MSFT"], options: {}, argument: "MSFT", rawArgument: "MSFT" }, "Financial Statements");
+  expect(text.match(/Historical versions unavailable\./g)).toHaveLength(1);
+  expect(text.indexOf("Historical versions unavailable.")).toBeLessThan(text.indexOf("VALUE"));
+  expect(text).toContain("96571000000");
+});
+
+
+test("series text distinguishes explicit percent, basis-point and index units without scaling exports", () => {
+  const definition: HeadlessPaneDefinition<"series"> = { shape: "series", argument: { kind: "none" }, options: [], load: () => ({ series: [] }) };
+  const result: HeadlessSeriesResult = { series: [
+    { id: "percent", label: "Credit percent", unit: "%", points: [{ date: "2026-09-10", value: 2.7 }] },
+    { id: "bp", label: "Credit basis points", unit: "bp", points: [{ date: "2026-09-10", value: 270 }] },
+    { id: "index", label: "Indexed value", unit: "index", points: [{ date: "2026-09-10", value: 102.5 }] },
+    { id: "missing", label: "Unknown unit", points: [{ date: "2026-09-10", value: 0 }] },
+    { id: "empty", label: "Missing value", unit: "%", points: [] },
+  ] };
+  const text = renderHeadlessPaneText(definition, result, args, "Research");
+  expect(text).toContain("UNIT");
+  expect(text.split("\n").find(line => line.includes("Credit percent"))).toMatch(/2\.7\s+%/);
+  expect(text.split("\n").find(line => line.includes("Credit basis points"))).toMatch(/270\s+bp/);
+  expect(text.split("\n").find(line => line.includes("Indexed value"))).toMatch(/102\.5\s+index/);
+  expect(text.split("\n").find(line => line.includes("Unknown unit"))).toMatch(/0\s+-/);
+  expect(text.split("\n").find(line => line.includes("Missing value"))).toMatch(/-\s+%/);
+  expect(jsonData(definition, result)).toMatchObject({ data: { series: result.series } });
+  const csv = serializeCliResult({ data: serializeHeadlessPaneResult(definition, result) }, { ...DEFAULT_CLI_OPTIONS, format: "csv" });
+  expect(csv).toContain('""unit"":""%"",""points"":[{""date"":""2026-09-10"",""value"":2.7}]');
+  expect(csv).toContain('""unit"":""bp"",""points"":[{""date"":""2026-09-10"",""value"":270}]');
+  expect(renderHeadlessPaneText(definition, { series: [result.series[3]!] }, args, "Unknown")).not.toContain("UNIT");
+});

package/src/cli/pane-functions/headless.ts

@@ -1,3 +1,5 @@
+import { getSharedRegistry } from "../../plugins/registry";
+import { parsePublicTickerKey } from "../../utils/exchanges";
 import { apiClient } from "../../api-client";
 import type { MarketContext } from "../types";
 import type {
@@ -48,7 +50,7 @@ function normalizeSymbol(value: string): string {
 function normalizeSymbolList(value: string): string[] {
   const symbols: string[] = [];
   const seen = new Set<string>();
-  for (const part of value.split(/[,\n]/)) {
+  for (const part of value.split(/[,\s]+/)) {
     const symbol = normalizeSymbol(part);
     if (!symbol || seen.has(symbol)) continue;
     seen.add(symbol);
@@ -138,11 +140,11 @@ export async function loadHeadlessPaneModel(
 
 /**
  * Loads the same renderer-neutral model used by `fn`.
- * A future screenshot payload can call this function instead of adding another fetch path.
+ * Both reports and screenshot payloads execute this loader.
  */
 export async function loadResolvedHeadlessPaneModel(
   resolved: ResolvedPaneFunction,
-  context: MarketContext,
+  context: Pick<MarketContext, "config" | "store"> & { dataProvider: HeadlessPaneContext["marketData"] },
   rawArgument: string,
   signal: AbortSignal = new AbortController().signal,
 ): Promise<LoadedHeadlessPaneModel> {
@@ -154,6 +156,14 @@ export async function loadResolvedHeadlessPaneModel(
     apiClient,
     config: context.config,
     signal,
+    settings: resolved.instance.settings,
+    capabilities: getSharedRegistry() ?? undefined,
+    async resolveInstrument(key) {
+      const parsed = parsePublicTickerKey(key);
+      const ticker = await context.store.loadTicker(key)
+        ?? (key !== parsed.symbol ? await context.store.loadTicker(parsed.symbol) : null);
+      return { symbol: parsed.symbol, exchange: parsed.exchange ?? ticker?.metadata.exchange };
+    },
   };
   const result = await loadHeadlessPaneModel(definition, args, headlessContext);
   return { definition, args, result };
@@ -315,6 +325,7 @@ function renderSeries(result: HeadlessSeriesResult): string[] {
       series: series.label,
       latest: latest ? displayValue(latest.date) : "-",
       value: latest?.value ?? latest?.close ?? null,
+      unit: series.unit?.trim() || null,
       points: series.points.length,
     };
   });
@@ -322,6 +333,7 @@ function renderSeries(result: HeadlessSeriesResult): string[] {
     { key: "series", header: "Series" },
     { key: "latest", header: "Latest" },
     { key: "value", header: "Value", align: "right" },
+    ...(rows.some((row) => row.unit) ? [{ key: "unit", header: "Unit" }] : []),
     { key: "points", header: "Points", align: "right" },
   ];
   const lines = [renderRows(rows, columns, undefined)];
@@ -346,6 +358,11 @@ export function renderHeadlessPaneText(
   fallbackTitle: string,
 ): string {
   const lines = [reportTitle(definition, args, fallbackTitle), ""];
+  const notices = result.metadata?.notices;
+  if (Array.isArray(notices)) {
+    const textNotices = [...new Set(notices.filter((notice): notice is string => typeof notice === "string" && notice.trim().length > 0))];
+    if (textNotices.length) lines.push(...textNotices, "");
+  }
   switch (definition.shape) {
     case "rows": {
       const rowsResult = result as HeadlessPaneResult & { rows: HeadlessPaneRow[]; columns?: HeadlessPaneColumn[] };
@@ -398,18 +415,19 @@ export async function buildHeadlessFunctionReport(
 ): Promise<PaneFunctionReport> {
   const loaded = await loadResolvedHeadlessPaneModel(resolved, context, rawArgument);
   const rowCount = resultRowCount(loaded.definition, loaded.result);
-  const unavailableSymbols = rowCount === 0 ? loaded.args.symbols : [];
+  const symbols = loaded.result.symbols ?? loaded.args.symbols;
+  const unavailableSymbols = loaded.result.unavailableSymbols ?? (rowCount === 0 ? symbols : []);
   const serialized = serializeHeadlessPaneResult(loaded.definition, loaded.result);
   return {
     data: {
       kind: loaded.definition.shape,
       target: resolved.token,
       capabilityId: resolved.capability.id,
-      symbols: loaded.args.symbols,
+      symbols,
       options: resolved.options,
       rowCount,
       empty: rowCount === 0,
-      complete: unavailableSymbols.length === 0 && !loaded.result.errors?.length,
+      complete: loaded.result.complete !== false && unavailableSymbols.length === 0 && !loaded.result.errors?.length,
       unavailableSymbols,
       ...serialized,
     },

package/src/cli/pane-functions/index.test.ts

@@ -1,5 +1,12 @@
+import { paneSchemas as chartSchemas } from "../../plugins/builtin/chart-composer/headless-schema";
+import { paneSchemas as tickerSchemas } from "../../plugins/builtin/ticker-detail/headless-schema";
+import { paneSchemas as correlationSchemas } from "../../plugins/builtin/correlation/headless-schema";
+import { paneSchemas as researchSchemas } from "../../plugins/builtin/research/headless-schema";
+import type { HeadlessPaneDefinition } from "../../types/headless";
 import { describe, expect, test } from "bun:test";
 import { paneFunctionTestInternals } from "./index";
+import { parseCliGlobalArgs } from "../options";
+import { thirteenFHeadless } from "../../plugins/builtin/thirteenf/headless";
 
 const {
   parsePaneFunctionArgs,
@@ -23,8 +30,13 @@ const dummyPane = {
 };
 
 function capabilityFor(templateId: string) {
+  const schemas: Record<string, Pick<HeadlessPaneDefinition, "argument" | "options" | "discovery">> = {
+    ...chartSchemas, ...tickerSchemas, ...correlationSchemas, ...researchSchemas,
+  };
+  const schema = schemas[templateId];
   return getPaneFunctionCapability({
     id: templateId,
+    ...(schema ? { headless: { ...schema, shape: "rows" as const, load: () => ({ rows: [] }) } } : {}),
     paneId: dummyPane.id,
     label: "Test",
     description: "Test",
@@ -32,6 +44,23 @@ function capabilityFor(templateId: string) {
 }
 
 describe("pane function CLI args", () => {
+  test("passes global limits through the pane schema instead of silently using its default", () => {
+    const capability = getPaneFunctionCapability({
+      id: "funds", paneId: dummyPane.id, label: "Funds", description: "Funds", headless: thirteenFHeadless,
+    }, dummyPane);
+    for (const flags of [["--limit", "15"], ["--limit=15"]]) {
+      const global = parseCliGlobalArgs(["fn", "13F", "1067983", ...flags, "--json"]);
+      const parsed = parsePaneFunctionArgs(global.args.slice(1), global.options);
+      expect(normalizeCapabilityOptions(capability, parsed.options, { strict: true }).limit).toBe(15);
+    }
+    const parsed = parsePaneFunctionArgs(["13F", "1067983"], { limit: 201 });
+    expect(() => normalizeCapabilityOptions(capability, parsed.options, { strict: true })).toThrow();
+  });
+  test("inline options do not consume the next positional instrument", () => {
+    expect(parsePaneFunctionArgs(["GP", "--range=1M", "ES=F"])).toMatchObject({
+      target: "GP", arg: "ES=F", options: { range: "1M" },
+    });
+  });
   test("parses target, argument, output, size, and pane options", () => {
     const parsed = parsePaneFunctionArgs([
       "FA",

package/src/cli/pane-functions/index.ts

@@ -41,7 +41,7 @@ async function withPaneRuntime<T>(
   }) => Promise<T>,
   settings: { strictHeadlessOptions?: boolean } = {},
 ): Promise<T> {
-  const parsed = parsePaneFunctionArgs(args);
+  const parsed = parsePaneFunctionArgs(args, ctx.cliOptions);
   return withMarketData(ctx, async (context) => {
     const registry = await createPaneCatalog(context, ctx.plugins);
     try {

package/src/cli/pane-functions/intraday-shot.test.ts

@@ -7,6 +7,9 @@ import {
   buildPriceChartPreset,
 } from "../../plugins/builtin/chart-composer/presets";
 import type { MarketContext } from "../types";
+import { chartHeadless } from "../../plugins/builtin/chart-composer/headless";
+import { applyChartComposerCapabilityOptions } from "../../plugins/builtin/chart-composer/cli-options";
+import { createTestDataProvider } from "../../test-support/data-provider";
 import {
   buildDesktopShotPayload,
   intradayChartEvidenceMismatchesFor,
@@ -14,9 +17,9 @@ import {
 } from "./screenshot";
 import type { ResolvedPaneFunction } from "./resolver";
 import {
-  resolveShotIntradaySessionWindow,
-  resolveShotIntradayRequest,
-} from "./intraday-shot";
+  resolveIntradaySessionWindow,
+  resolveIntradayRequest,
+} from "../../time-series/session-history";
 
 function sessionBars(date: string, base: number): PricePoint[] {
   return [
@@ -83,11 +86,13 @@ function contextWithProvider(provider: DataProvider): MarketContext {
 }
 
 function resolvedChart(
-  capabilityId: "intraday-price-chart" | "price-chart",
+  capabilityId: "intraday-price-chart" | "price-chart" | "chart-composer",
   spec: ReturnType<typeof buildIntradayPriceChartPreset>,
   options: Record<string, string>,
 ): ResolvedPaneFunction {
   return {
+    token: "chart-test",
+    headless: chartHeadless(capabilityId === "intraday-price-chart" ? "graph-intraday-price-pane" : capabilityId === "price-chart" ? "graph-price-pane" : "chart-composer-pane"),
     pane: { id: CHART_COMPOSER_PANE_ID },
     capability: { id: capabilityId, options: [] },
     options,
@@ -96,7 +101,7 @@ function resolvedChart(
       paneId: CHART_COMPOSER_PANE_ID,
       title: "AAPL",
       binding: { kind: "fixed", symbol: "AAPL" },
-      settings: { chartSpec: spec },
+      settings: { chartSpec: applyChartComposerCapabilityOptions(spec, capabilityId, options) },
     },
     createOptions: { symbol: "AAPL" },
   } as unknown as ResolvedPaneFunction;
@@ -130,14 +135,14 @@ describe("GIP session windows", () => {
   ];
 
   test("resolves the latest session, latest five sessions, and an explicit session", () => {
-    const latest = resolveShotIntradaySessionWindow(history, {
+    const latest = resolveIntradaySessionWindow(history, {
       rangePreset: "1D",
       timeZone: "America/New_York",
     });
     expect(latest.sessionDates).toEqual(["2026-09-03"]);
     expect(latest.points).toHaveLength(2);
 
-    const week = resolveShotIntradaySessionWindow(history, {
+    const week = resolveIntradaySessionWindow(history, {
       rangePreset: "1W",
       timeZone: "America/New_York",
     });
@@ -150,7 +155,7 @@ describe("GIP session windows", () => {
     ]);
     expect(week.points).toHaveLength(10);
 
-    const explicit = resolveShotIntradaySessionWindow(history, {
+    const explicit = resolveIntradaySessionWindow(history, {
       rangePreset: "1W",
       session: "2026-09-01",
       timeZone: "America/New_York",
@@ -160,16 +165,16 @@ describe("GIP session windows", () => {
   });
 
   test("maps Auto to the preset interval and validates explicit dates", () => {
-    expect(resolveShotIntradayRequest({ rangePreset: "1D", chartResolution: "auto" }))
+    expect(resolveIntradayRequest({ rangePreset: "1D", chartResolution: "auto" }))
       .toEqual({ rangePreset: "1D", resolution: "1m", session: null });
-    expect(resolveShotIntradayRequest({ rangePreset: "1W", chartResolution: "auto" }))
+    expect(resolveIntradayRequest({ rangePreset: "1W", chartResolution: "auto" }))
       .toEqual({ rangePreset: "1W", resolution: "5m", session: null });
-    expect(resolveShotIntradayRequest({
+    expect(resolveIntradayRequest({
       rangePreset: "1W",
       chartResolution: "15m",
       session: "2026-09-02",
     })).toEqual({ rangePreset: "1D", resolution: "15m", session: "2026-09-02" });
-    expect(() => resolveShotIntradayRequest({ session: "2026-02-30" }))
+    expect(() => resolveIntradayRequest({ session: "2026-02-30" }))
       .toThrow("real calendar date");
   });
 });
@@ -178,7 +183,7 @@ describe("GIP screenshot payload", () => {
   test("injects resolution-aware intraday bars for GIP", async () => {
     const calls: Array<{ range: string; resolution: string }> = [];
     const history = [
-      ...sessionBars("2026-09-02", 100),
+      ...sessionBars("2026-09-02", 100).map((point) => ({ ...point, date: new Date(point.date.getTime() + 6 * 60 * 60_000) })),
       ...sessionBars("2026-09-03", 105),
     ];
     const provider = {
@@ -196,6 +201,7 @@ describe("GIP screenshot payload", () => {
     } as DataProvider;
     const spec = buildIntradayPriceChartPreset("AAPL");
     spec.viewport.resolution = "auto";
+    spec.studies.push({ id: "average", kind: "sma", inputSeriesIds: [spec.series[0]!.id], parameters: { period: 3 }, panelId: "main", axis: "left" });
     const payload = await payloadFor(
       resolvedChart("intraday-price-chart", spec, {
         rangePreset: "1D",
@@ -216,7 +222,8 @@ describe("GIP screenshot payload", () => {
       unavailableReason: null,
     });
     expect(payload.intradayHistories[0]?.points).toHaveLength(2);
-    expect(payload.financials[0]?.[1].priceHistory).toHaveLength(2);
+    expect(payload.financials[0]?.[1].priceHistory).toHaveLength(4);
+    expect(payload.chartModel?.series.find(({ id }) => id === "average")?.points[0]?.value).toBe(102);
 
     const renderedEvidence = [{
       role: "chart-data",
@@ -241,8 +248,8 @@ describe("GIP screenshot payload", () => {
       .toContain("rendered intraday point count does not match");
   });
 
-  test("keeps GP on daily history without an intraday payload", async () => {
-    let intradayCalls = 0;
+  test("uses GP's preset resolution without applying GIP session selection", async () => {
+    const resolutions: string[] = [];
     const daily = [
       { date: new Date("2026-09-02T00:00:00.000Z"), close: 100 },
       { date: new Date("2026-09-03T00:00:00.000Z"), close: 105 },
@@ -252,9 +259,9 @@ describe("GIP screenshot payload", () => {
       name: "Test",
       getTickerFinancials: async () => financials(),
       getPriceHistory: async () => daily,
-      getPriceHistoryForResolution: async () => {
-        intradayCalls += 1;
-        return [];
+      getPriceHistoryForResolution: async (_symbol, _exchange, _range, resolution) => {
+        resolutions.push(resolution);
+        return daily;
       },
     } as DataProvider;
     const payload = await payloadFor(
@@ -262,11 +269,52 @@ describe("GIP screenshot payload", () => {
       provider,
     );
 
-    expect(intradayCalls).toBe(0);
+    expect(resolutions).toEqual(["1h"]);
     expect(payload.intradayHistories).toEqual([]);
     expect(payload.financials[0]?.[1].priceHistory).toEqual(daily);
   });
 
+  test("captures the historical chart request and its study buffer once, without current-range prefetches", async () => {
+    const calls: Array<{ start: Date; end: Date; resolution: string }> = [];
+    const history = Array.from({ length: 45 }, (_, index) => ({
+      date: new Date(Date.UTC(2019, 11, 1 + index, 13, 30)),
+      close: 100 + index, volume: 1_000,
+    }));
+    const spec = buildPriceChartPreset("AAPL:NASDAQ");
+    spec.viewport = { range: "1Y", resolution: "1d", dateWindow: { start: "2020-01-02T00:00:00Z", end: "2020-01-04T23:59:59Z" } };
+    spec.studies.push({ id: "average", kind: "sma", inputSeriesIds: [spec.series[0]!.id], parameters: { period: 5 }, panelId: "main", axis: "left" });
+    // A later non-price field must not replace the captured history with the
+    // unrelated default price history carried by a financials response.
+    spec.series.push({ ...spec.series[0]!, id: "revenue", source: { kind: "security", instrument: { symbol: "AAPL", exchange: "NASDAQ" }, fieldId: "fundamental.totalRevenue", period: "annual" } });
+    let financialCalls = 0;
+    const provider = createTestDataProvider({
+      getTickerFinancials: async () => {
+        financialCalls += 1;
+        await Promise.resolve();
+        return financials([{ date: new Date("2026-09-03T00:00:00Z"), close: 200 }]);
+      },
+      getPriceHistory: async () => { throw new Error("Screenshot must not prefetch a trailing range"); },
+      getDetailedPriceHistory: async (_symbol, _exchange, start, end, resolution) => {
+        calls.push({ start, end, resolution });
+        return history.filter((point) => point.date >= start && point.date < end);
+      },
+    });
+    const payload = await payloadFor(resolvedChart("chart-composer", spec, {}), provider);
+    expect(calls).toHaveLength(1);
+    expect(calls[0]?.resolution).toBe("1d");
+    expect(calls[0]!.start.getTime()).toBeLessThan(Date.parse(spec.viewport.dateWindow!.start));
+    expect(financialCalls).toBe(1);
+    expect(payload.chartModel?.series[0]?.points).toHaveLength(3);
+    const average = payload.chartModel?.series.find(({ id }) => id === "average");
+    expect(average?.points).toHaveLength(3);
+    expect(average?.points[0]?.value).toBe(130);
+    const captured = payload.financials[0]![1];
+    expect(captured.priceHistory.length).toBeGreaterThan(3);
+    expect(captured.priceHistory.at(-1)?.date.toISOString()).toBe("2020-01-04T13:30:00.000Z");
+    expect(captured.quote?.price).toBe(108);
+    expect((payload.config.layout.instances[0]!.settings!.chartSpec as typeof spec).viewport.dateWindow).toEqual(spec.viewport.dateWindow);
+  });
+
   test("records an explicit unusable reason when no intraday bars exist", async () => {
     const provider = {
       id: "test",
@@ -304,4 +352,20 @@ describe("GIP screenshot payload", () => {
       false,
     )).toBe("No intraday price history is available for AAPL for session 2020-01-02.");
   });
+
+  test("keeps an authored GIP window and its intraday evidence when capturing the resolved model", async () => {
+    let historyCalls = 0;
+    const spec = buildIntradayPriceChartPreset("AAPL");
+    spec.viewport = { range: "1W", resolution: "5m", dateWindow: { start: "2020-01-02T13:30:00Z", end: "2020-01-03T13:35:00Z" } };
+    const points = [...sessionBars("2020-01-02", 100), ...sessionBars("2020-01-03", 105)];
+    const payload = await payloadFor(resolvedChart("intraday-price-chart", spec, {}), createTestDataProvider({
+      getDetailedPriceHistory: async () => { historyCalls += 1; return points; },
+    }));
+    expect(historyCalls).toBe(1);
+    expect(payload.chartModel?.series[0]?.points).toHaveLength(4);
+    expect(payload.intradayHistories[0]).toMatchObject({
+      sessionDates: ["2020-01-02", "2020-01-03"], points, resolution: "5m", unavailableReason: null,
+    });
+    expect((payload.config.layout.instances[0]!.settings!.chartSpec as typeof spec).viewport.dateWindow).toEqual(spec.viewport.dateWindow);
+  });
 });

package/src/cli/pane-functions/options.ts

@@ -62,7 +62,7 @@ export function parseArgumentsOption(value: string): Record<string, string> {
   return pairs;
 }
 
-export function parsePaneFunctionArgs(args: string[]): ParsedPaneFunctionArgs {
+export function parsePaneFunctionArgs(args: string[], globalOptions: { limit?: number } = {}): ParsedPaneFunctionArgs {
   const positionals: string[] = [];
   const options: Record<string, string | true> = {};
   let outputPath: string | null = null;
@@ -90,7 +90,7 @@ export function parsePaneFunctionArgs(args: string[]): ParsedPaneFunctionArgs {
     const key = equalsIndex >= 0 ? raw.slice(0, equalsIndex) : raw;
     const inlineValue = equalsIndex >= 0 ? raw.slice(equalsIndex + 1) : undefined;
     const next = args[index + 1];
-    const nextValue = next && !next.startsWith("--") ? args[++index] : true;
+    const nextValue = inlineValue === undefined && next && !next.startsWith("--") ? args[++index] : true;
     const value: string | true = inlineValue ?? nextValue ?? true;
     const normalizedKey = normalizeOptionKey(key);
     if (normalizedKey === "requireBotSafe" || normalizedKey === "botSafe") {
@@ -122,6 +122,9 @@ export function parsePaneFunctionArgs(args: string[]): ParsedPaneFunctionArgs {
 
   const target = positionals[0]?.trim() ?? "";
   const arg = positionals.slice(1).join(" ").trim();
+  // The outer CLI parser consumes --limit before fn/shot sees its arguments.
+  // Restore it for the pane's own schema and loader, including bounds checks.
+  if (globalOptions.limit != null) options.limit = String(globalOptions.limit);
   return { target, arg, options, outputPath, width, height, theme, scale, watermark, requireBotSafe };
 }