@gloom-sh/terminal 0.19.0 → 0.19.1

package/src/plugins/builtin/alerts/cli.ts

@@ -11,6 +11,9 @@ import { quoteAlertFields } from "./quotes";
 import { createEventAlert } from "./events";
 import { isResearchAlertKind, readResearchRule } from "./research-rules";
 import { withConfigData, withMarketData } from "../../../cli/scoped-context";
+import { resolvePersistedCloudSessionToken } from "../../../cli/pane-functions/cloud-session";
+import type { ConfigContext } from "../../../cli/types";
+import { checkedWhenSignedIn, NEEDS_SIGN_IN, needsSignInNote } from "./event-rows";
 import { CLI_COMMAND_GROUPS } from "../../../cli/help";
 import { dryRunNote } from "../../../cli/helpers";
 import { requireArg, takeOption } from "../../../cli/commands/command-utils";
@@ -445,11 +448,13 @@ function priceRow(alert: AlertRule): AlertListRow {
 }
 
 function eventRow(
-  rule: EventAlertRule, now: number, eventDate: string | null | undefined, check?: IvLevelCheck, cloud?: CloudRuleStates,
+  rule: EventAlertRule, now: number, eventDate: string | null | undefined, check?: IvLevelCheck, cloud?: CloudRuleStates, signedIn = true,
 ): AlertListRow {
   const scheduled = readScheduledRule(rule);
   if (!scheduled) {
-    const status = rule.status === "active" && rule.triggeredAt ? "triggered" : rule.status;
+    const triggered = rule.status === "active" && rule.triggeredAt ? "triggered" : rule.status;
+    // Signed out, nothing checks a rule only a signed-in account gets checked: it waits on a sign-in, not on its event.
+    const status = triggered === "active" && !signedIn && checkedWhenSignedIn(rule) ? NEEDS_SIGN_IN : triggered;
     // An IV level is read by this app, so its last reading is this device's; Gloom Cloud reads the rest.
     const state = cloud?.states.get(rule.id);
     const reading = rule.kind === "iv_level" ? {
@@ -489,11 +494,14 @@ interface CloudRuleStates {
 
 /**
  * Gloom Cloud checks the event rules this app does not, for a signed-in account. With no session nothing has
- * read them, so they are not checked yet; with one, their readings are Cloud's.
+ * read them, so they are not checked yet; with one (`session`, the app's saved one), their readings are Cloud's.
+ * The command runs with that session from here on, as market commands do (`initMarketData`): it is set once and
+ * never put back, so the earnings-date lookup running beside this never loses it midway.
  */
-async function cloudRuleStates(rules: readonly EventAlertRule[]): Promise<CloudRuleStates> {
+async function cloudRuleStates(rules: readonly EventAlertRule[], session: string | null): Promise<CloudRuleStates> {
   const empty = { states: new Map<string, AlertRuleState>(), failed: false };
-  if (!apiClient.getSessionToken() || !rules.some((rule) => rule.kind !== "iv_level" && !readScheduledRule(rule))) return empty;
+  if (!session || !rules.some(checkedWhenSignedIn)) return empty;
+  apiClient.setSessionToken(session);
   try {
     const history = await fetchAlertHistory(0);
     return { states: new Map(history.states.map((state) => [state.ruleId, state])), failed: false };
@@ -502,6 +510,12 @@ async function cloudRuleStates(rules: readonly EventAlertRule[]): Promise<CloudR
   }
 }
 
+/** The Gloom Cloud session the app saved after sign-in, as `fn` and market commands read with; null signed out. */
+function savedSession(config: Partial<Pick<ConfigContext, "persistence">>): string | null {
+  const persistence = config.persistence;
+  return apiClient.getSessionToken() ?? (persistence?.pluginState ? resolvePersistedCloudSessionToken({ persistence }) : null);
+}
+
 /** The listing a research rule follows (AAPL, ADYEN:AMS for a hiring rule); empty for one on no symbol. */
 function eventRuleListing(rule: EventAlertRule): string {
   if (rule.target === "ticker") return rule.value;
@@ -938,20 +952,23 @@ export const alertsCliCommand: CliCommandDef = {
 
     if (action === "list") {
       // An IV level's last reading is this device's, beside the rules.
-      const { alerts, alertsError, events, checks } = await withConfigData(ctx, (config) => ({
+      const { alerts, alertsError, events, checks, session } = await withConfigData(ctx, (config) => ({
         ...readAlertStores(config.config),
         checks: readIvLevelChecks(config.persistence?.pluginState?.get(ALERTS_PLUGIN_ID, resumeStateKey(IV_LEVEL_CHECKS_KEY))?.value),
+        session: savedSession(config),
       }));
       // Earnings dates come through market data; CPI, FOMC and calendar dates do not need it.
       const lookup = (targets: ScheduledEventTarget[]) => targets.some((target) => target.kind === "earnings")
         ? withMarketData(ctx, (market) => lookupScheduledDates(targets, scheduledEventSources(market.dataProvider), today, now))
         : lookupScheduledDates(targets, scheduledEventSources(null), today, now);
-      const [{ dates, warnings }, cloud] = await Promise.all([listEventDates(events.rules, now, lookup), cloudRuleStates(events.rules)]);
+      const [{ dates, warnings }, cloud] = await Promise.all([listEventDates(events.rules, now, lookup), cloudRuleStates(events.rules, session)]);
       const rows = [
         ...alerts.map(priceRow),
-        ...events.rules.map((rule) => eventRow(rule, now, dates.has(rule.id) ? dates.get(rule.id) : rule.eventDate, checks[rule.id], cloud)),
+        ...events.rules.map((rule) => eventRow(rule, now, dates.has(rule.id) ? dates.get(rule.id) : rule.eventDate, checks[rule.id], cloud, !!session)),
       ];
-      const allWarnings = [...(alertsError ? [alertsError] : []), ...(events.error ? [events.error] : []), ...warnings, ...cloud.warning ? [cloud.warning] : []];
+      const waiting = rows.filter((row) => row.status === NEEDS_SIGN_IN).length;
+      const allWarnings = [...(alertsError ? [alertsError] : []), ...(events.error ? [events.error] : []), ...warnings, ...cloud.warning ? [cloud.warning] : [],
+        ...waiting ? [needsSignInNote(waiting)] : []];
       ctx.printResult({ data: rows, ...(allWarnings.length ? { warnings: allWarnings } : {}) }, {
         rows: (data) => data.map(textRow),
         textColumns: [
@@ -1048,8 +1065,14 @@ export const alertsCliCommand: CliCommandDef = {
         await save({ events: [...rules, rule] });
         record("created", rule);
         const delivery = research ? researchDelivery(research.kind) : ruleDelivery(formRule!.event);
-        ctx.printResult({ data: { changed: !ctx.cliOptions.dryRun, dryRun: ctx.cliOptions.dryRun, alert: rule }, ...(read.length > 0 ? { warnings: read } : {}) }, {
-          text: (data) => `Added alert ${data.alert.id}: ${alertKindLabel(rule.kind)} ${eventAlertTarget(rule)} (${delivery}).${dryRunNote(data.dryRun)}`,
+        // Saved signed out, it waits on a sign-in, and `alerts list` and ALRT say so until there is one.
+        const needsSignIn = checkedWhenSignedIn(rule) && !savedSession(config);
+        const signIn = needsSignIn
+          ? " It needs sign-in: nothing checks it while you are signed out. Open the app (gloom) and log in or sign up free from the command bar (Ctrl+P, Log In or Sign Up)."
+          : "";
+        ctx.printResult({ data: { changed: !ctx.cliOptions.dryRun, dryRun: ctx.cliOptions.dryRun, alert: rule, ...needsSignIn ? { status: NEEDS_SIGN_IN } : {} },
+          ...(read.length > 0 ? { warnings: read } : {}) }, {
+          text: (data) => `Added alert ${data.alert.id}: ${alertKindLabel(rule.kind)} ${eventAlertTarget(rule)} (${delivery}).${signIn}${dryRunNote(data.dryRun)}`,
         });
         return;
       }

package/src/plugins/builtin/alerts/event-rows.ts

@@ -8,13 +8,34 @@ export function ruleTarget(rule: EventAlertRule): string {
   return `${target} · ${rule.eventDate ?? "date not known yet"}`;
 }
 
+/**
+ * Whether a rule is checked only for a signed-in account: Gloom Cloud checks every event rule but an IV level
+ * and an earnings, CPI, FOMC or calendar date, which the app reads itself, signed in or not, and the app reads
+ * catalysts only with a session. Signed out, such a rule never goes off.
+ */
+export function checkedWhenSignedIn(rule: EventAlertRule): boolean {
+  return rule.kind !== "iv_level" && !readScheduledRule(rule);
+}
+
+/** The state of a waiting rule nothing checks while signed out, as `alerts list` and its CSV write it. */
+export const NEEDS_SIGN_IN = "needs sign-in";
+
+/** What a list of rules says once when some of them need sign-in: what to do about it. */
+export function needsSignInNote(count: number): string {
+  return `${count === 1 ? "1 event alert needs" : `${count} event alerts need`} sign-in: ${count === 1 ? "it is" : "they are"} checked only for a signed-in account. `
+    + "Open the app (gloom) and log in or sign up free from the command bar (Ctrl+P, Log In or Sign Up).";
+}
+
 /**
  * The state word the Events tab shows: a scheduled rule is Alerted once it has gone off for its coming
- * event, an IV level once its level was reached, until it is re-armed.
+ * event, an IV level once its level was reached, until it is re-armed. Signed out, a waiting rule only a
+ * signed-in account gets checked needs sign-in.
  */
-export function ruleState(rule: EventAlertRule, now: number = Date.now()): "Active" | "Paused" | "Alerted" {
+export function ruleState(rule: EventAlertRule, now: number = Date.now(), signedIn = true): "Active" | "Paused" | "Alerted" | "Needs sign-in" {
   const scheduled = readScheduledRule(rule);
   const status = scheduled ? scheduledAlertStatus(rule, scheduled.leadDays, scheduledToday(scheduled.target, now), scheduled.trigger)
     : rule.status === "active" && rule.kind === "iv_level" && rule.triggeredAt ? "triggered" : rule.status;
-  return status === "paused" ? "Paused" : status === "triggered" ? "Alerted" : "Active";
+  if (status === "paused") return "Paused";
+  if (status === "triggered") return "Alerted";
+  return !signedIn && checkedWhenSignedIn(rule) ? "Needs sign-in" : "Active";
 }

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

@@ -31,6 +31,7 @@ import { alertKindLabel, fetchAlertHistory, ruleStateText } from "./history";
 import { isResearchAlertKind } from "./research-rules";
 import { useAsyncResource } from "../../../public/react";
 import { usePlanAccess } from "../../../api-client/plan-access";
+import { apiClient } from "../../../api-client";
 import { useResearchCloudSession } from "../shared/research-cloud-session";
 import { rearmScheduledAlert } from "./scheduled";
 import { checkScheduledEventAlertsNow } from "./scheduled-check";
@@ -39,13 +40,14 @@ import { alertTarget, alertViewHints, eventRuleSubject, useOpenAlertTarget } fro
 import { FIRED_LOG_KEY } from "./fired-log";
 import { withAlertChange } from "./alert-log";
 
-const columnsFor = (width: number, lastCheck: boolean): DataTableColumn[] => [
+const columnsFor = (width: number, lastCheck: boolean, needsSignIn: boolean): DataTableColumn[] => [
   { id: "kind", label: "Event", width: 15, align: "left" },
   { id: "target", label: "Following", width: 28, flexGrow: 1, align: "left" },
   ...(lastCheck && width >= 96
     ? [{ id: "last", label: "Last check", width: 34, align: "left" as const }]
     : []),
-  { id: "status", label: "State", width: 8, align: "left" },
+  // Wide enough to say "Needs sign-in" only when a row does.
+  { id: "status", label: "State", width: needsSignIn ? 13 : 8, align: "left" },
   { id: "created", label: "Since", width: 10, align: "left" },
 ];
 
@@ -97,10 +99,13 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
   const selectedRule = items[Math.min(selected, Math.max(0, items.length - 1))];
   const now = Date.now();
   const selectedFired = !!selectedRule && ruleState(selectedRule, now) === "Alerted";
-  const openTarget = useOpenAlertTarget();
-  const selectedTarget = useMemo(() => selectedRule ? alertTarget(eventRuleSubject(selectedRule)) : null, [selectedRule]);
   // Research rules keep a dated observation in the Cloud; show its value and percentile.
   const access = usePlanAccess();
+  // A saved session counts before its account has loaded, so a signed-in start does not flash "Needs sign-in".
+  const signedIn = access.signedIn || !!apiClient.getSessionToken();
+  const needsSignIn = !signedIn && rules.some((rule) => ruleState(rule, now, false) === "Needs sign-in");
+  const openTarget = useOpenAlertTarget();
+  const selectedTarget = useMemo(() => selectedRule ? alertTarget(eventRuleSubject(selectedRule)) : null, [selectedRule]);
   const session = useResearchCloudSession();
   const hasResearch = rules.some((rule) => isResearchAlertKind(rule.kind) && rule.kind !== "iv_level");
   const stateLoader = useCallback(() => fetchAlertHistory(0), [session.requestKey]);
@@ -110,7 +115,7 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
     [history.data],
   );
   // An IV level is read by this app, so its last reading needs no session.
-  const columns = columnsFor(width, (hasResearch && !!history.data) || rules.some((rule) => rule.kind === "iv_level"));
+  const columns = columnsFor(width, (hasResearch && !!history.data) || rules.some((rule) => rule.kind === "iv_level"), needsSignIn);
   const add = useCallback(
     () => openPluginCommandWorkflow("set-event-alert"),
     [openPluginCommandWorkflow],
@@ -216,7 +221,9 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
         // An IV level that could not be read says so on its own row: No data in State, the reason in Last check.
         const check = rule.kind === "iv_level" ? checks[rule.id] : undefined;
         const unread = rule.kind === "iv_level" && rule.status === "active" && !rule.triggeredAt && check?.value === null;
-        const state = ruleState(rule, now);
+        const state = ruleState(rule, now, signedIn);
+        // A rule nothing checks while signed out says so in its State, in the warning tone.
+        const waiting = state === "Needs sign-in" && column.id === "status";
         return {
           text:
             column.id === "kind"
@@ -236,6 +243,8 @@ export function EventAlertsPane({ focused, width, height }: PaneProps) {
             ? colors.selectedText
             : unread && (column.id === "status" || column.id === "last")
               ? colors.negative
+              : waiting
+                ? colors.warning
               : rule.status === "paused"
                 ? colors.textMuted
                 : colors.text,

package/src/plugins/builtin/alerts/headless.ts

@@ -10,7 +10,7 @@ import type { HeadlessPaneColumn, HeadlessPaneContext, HeadlessPaneDefinition, H
 import type { PaneLock } from "../../../types/plugin";
 import { refusedLock } from "../shared/cloud-denied";
 import { ALERT_TABS, ALERTS_PLUGIN_ID } from "./constants";
-import { ruleState } from "./event-rows";
+import { needsSignInNote, ruleState } from "./event-rows";
 import { eventAlertTarget, type EventAlertRule } from "./events";
 import {
   alertListing,
@@ -141,7 +141,7 @@ function pricesResult(alerts: readonly AlertRule[], error: string | null, events
 }
 
 /** An event alert as the Events table lists it: a scheduled one with its event date and lead time apart. */
-function eventRow(rule: EventAlertRule, now: number, checks: Record<string, IvLevelCheck>): HeadlessPaneRow {
+function eventRow(rule: EventAlertRule, now: number, checks: Record<string, IvLevelCheck>, signedIn: boolean): HeadlessPaneRow {
   const scheduled = readScheduledRule(rule);
   return {
     id: rule.id,
@@ -151,22 +151,26 @@ function eventRow(rule: EventAlertRule, now: number, checks: Record<string, IvLe
     eventDate: scheduled ? rule.eventDate ?? null : null,
     leadDays: scheduled?.leadDays ?? null,
     ...(scheduled?.trigger === "results" ? { when: "results" } : {}),
-    state: ruleState(rule, now),
+    state: ruleState(rule, now, signedIn),
     since: new Date(rule.createdAt).toISOString().slice(0, 10),
     // An IV level's last reading, or why there was none, on its own row.
     ...rule.kind === "iv_level" ? { lastCheck: ivLevelCheckText(rule, checks[rule.id]) } : {},
   };
 }
 
-function eventsResult(rules: readonly EventAlertRule[], error: string | null, checks: Record<string, IvLevelCheck>): HeadlessRowsResult {
+function eventsResult(rules: readonly EventAlertRule[], error: string | null, checks: Record<string, IvLevelCheck>, signedIn: boolean): HeadlessRowsResult {
   const now = Date.now();
   const checked = rules.some((rule) => rule.kind === "iv_level");
+  const rows = [...rules].sort((a, b) => b.createdAt - a.createdAt).map((rule) => eventRow(rule, now, checks, signedIn));
+  // Signed out, the rules only a signed-in account gets checked say so on their rows, and once what to do.
+  const waiting = rows.filter((row) => row.state === "Needs sign-in").length;
   return {
     // A Last check column only when an IV level rule has a reading to show.
     columns: checked ? [...EVENT_COLUMNS.slice(0, -2), { key: "lastCheck", header: "Last check" }, ...EVENT_COLUMNS.slice(-2)] : EVENT_COLUMNS,
-    rows: [...rules].sort((a, b) => b.createdAt - a.createdAt).map((rule) => eventRow(rule, now, checks)),
+    rows,
     empty: "No event alerts. Add one with gloom alerts add CRWV earnings --days 3, gloom alerts add CPI --days 1 or gloom alerts add CN PMI.",
     ...(error ? { errors: [error], complete: false } : {}),
+    ...(waiting ? { notes: [needsSignInNote(waiting)] } : {}),
   };
 }
 
@@ -260,7 +264,7 @@ export const alertsHeadless: HeadlessPaneDefinition<"rows"> = {
     if (tab === "history") return historyResult(ctx);
     const { alerts, alertsError, events } = readAlertStores(ctx.config);
     return tab === "events"
-      ? eventsResult(events.rules, events.error, readIvLevelChecks(ctx.readDeviceState?.(ALERTS_PLUGIN_ID, IV_LEVEL_CHECKS_KEY)))
+      ? eventsResult(events.rules, events.error, readIvLevelChecks(ctx.readDeviceState?.(ALERTS_PLUGIN_ID, IV_LEVEL_CHECKS_KEY)), !!ctx.apiClient.getSessionToken?.())
       : pricesResult(alerts, alertsError, events.rules.length);
   },
 };

package/src/plugins/builtin/cds/client.ts

@@ -9,6 +9,8 @@ import type { CloudCdsHistoryParams } from "../../../api-client/paths";
 import type { InstrumentSearchResult } from "../../../types/instrument";
 import {
   cdsReferenceEntity,
+  closestCoveredIssuers,
+  coveredIssuerMatch,
   issuerNameOf,
   normalizeCdsTrades,
   spreadLevelsOf,
@@ -29,6 +31,12 @@ export interface CdsActivity {
   query: string | null;
   /** The issuer name actually sent, after any symbol lookup. */
   issuer: string | null;
+  /**
+   * Set when a name matched no covered issuer and was sent as typed or as its
+   * listing's name: the covered issuers closest to what was typed, for the
+   * view to offer when the tape has nothing under it either.
+   */
+  unmatched?: { nearest: string[] } | null;
   /** How many days of the tape the trades cover. */
   days: number;
   trades: CdsTrade[];
@@ -38,61 +46,164 @@ export type CdsActivityLoader = (issuer: string | null) => Promise<CdsActivity>;
 
 export type CdsFetch = (params: { issuer?: string; days?: number; limit?: number }) => Promise<CloudCdsResponse>;
 export type InstrumentSearch = (query: string, limit?: number) => Promise<InstrumentSearchResult[]>;
+/** The names of the issuers whose 5Y line has a level, as the tape spells them. */
+export type CoveredIssuers = () => Promise<readonly string[]>;
 
 /**
- * A bare ticker with normal symbol punctuation and no spaces. Anything longer or
- * containing a space is already a company name and is sent as the tape would
- * name it.
+ * A ticker as typed: symbol punctuation, no spaces, and no lowercase letter.
+ * `WHR` and `BRK.B` are tickers; `goodyear` and `Paramount` are names.
  */
-const TICKER_LIKE = /^[A-Za-z0-9][A-Za-z0-9.^:-]{0,11}$/;
+const TICKER_LIKE = /^[A-Z0-9][A-Z0-9.^:-]{0,11}$/;
 const US_PRIMARY_EXCHANGES = new Set(["AMEX", "NASDAQ", "NYSE", "NYSEAMERICAN", "NYSEARCA"]);
 
+/** The US venues besides the primary exchanges a listing can trade on: a receipt's or a delisted company's line. */
+const US_OTHER_EXCHANGES = new Set(["ARCA", "BATS", "IEX", "OTC", "OTCMKTS", "PNK"]);
+
+const listingExchange = (result: InstrumentSearchResult) => (result.primaryExchange || result.exchange).toUpperCase().replace(/[^A-Z]/g, "");
+
 function isPrimaryUsCommonStock(result: InstrumentSearchResult): boolean {
-  const exchange = (result.primaryExchange || result.exchange).toUpperCase().replace(/[^A-Z]/g, "");
   const type = result.type.toLowerCase();
   return result.currency === "USD"
-    && US_PRIMARY_EXCHANGES.has(exchange)
+    && US_PRIMARY_EXCHANGES.has(listingExchange(result))
     && (type === "stk" || type === "equity" || type.includes("common stock"));
 }
 
+/** A line on a US venue in dollars (a receipt, a line over the counter); a listing abroad is not one. */
+function isUsLine(result: InstrumentSearchResult): boolean {
+  const exchange = listingExchange(result);
+  return (!result.currency || result.currency === "USD") && (US_PRIMARY_EXCHANGES.has(exchange) || US_OTHER_EXCHANGES.has(exchange));
+}
+
 /**
- * The backend matches DTCC issuer names, so a ticker has to become a company
- * name first: its reference entity when the debt sits with another entity,
- * else the listed company's name without its share class ("Alphabet Inc.",
- * not "Alphabet Inc. Class A Common Stock"). An untracked symbol has no local
- * metadata to expand it, and its quote name never arrives for a fixed
- * binding, so the shared instrument search is the only reliable expansion. A
- * search outage falls back to the raw input rather than taking the CDS
- * request down with it.
+ * Whether a listing carries what was typed: the words in its name or a name
+ * search knows it by (`searchAliases`), or a ticker it had (`formerIssuer`:
+ * BRCM on Broadcom Inc.). The first US hit for a name that does not is
+ * another company.
  */
+function carriesTyped(result: InstrumentSearchResult, typed: string): boolean {
+  const symbol = typed.toUpperCase();
+  if (result.formerIssuer?.symbol?.toUpperCase() === symbol) return true;
+  return [result.name, ...result.searchAliases ?? [], result.formerIssuer?.name]
+    .some((name) => !!name && coveredIssuerMatch(typed, [name]) != null);
+}
+
+/** The covered issuers' names, from the same request as their levels. */
+export function coveredIssuersFrom(fetchLevels: CdsLevelsFetch): CoveredIssuers {
+  return async () => ((await fetchLevels()).levels ?? []).flatMap((level) => (typeof level.issuer === "string" ? [level.issuer] : []));
+}
+
+const defaultCoveredIssuers = coveredIssuersFrom(() => apiClient.getCloudCdsLevels());
+
+async function searchOrNone(searchInstruments: InstrumentSearch, query: string): Promise<InstrumentSearchResult[]> {
+  try {
+    return await searchInstruments(query);
+  } catch {
+    // Intentional ignore: a search outage sends the name as typed instead of failing the CDS request.
+    return [];
+  }
+}
+
+async function coveredOrNone(coveredIssuers: CoveredIssuers): Promise<readonly string[]> {
+  try {
+    return await coveredIssuers();
+  } catch {
+    // Intentional ignore: without the covered list the name goes on to the listing and the tape.
+    return [];
+  }
+}
+
+interface CdsIssuerResolution {
+  /** The name the tape is asked for. */
+  issuer: string;
+  /** Set when a name matched no covered issuer; see `CdsActivity.unmatched`. */
+  unmatched: { nearest: string[] } | null;
+}
+
+/**
+ * The backend matches DTCC issuer names, so what was typed has to become one.
+ *
+ * Any one-word input, whatever its case (`CHTR`, `chtr`), is first looked up
+ * among the tickers whose debt sits with another entity: CHTR is CCO
+ * Holdings, LLC.
+ *
+ * A ticker (`WHR`) becomes the listed company's name without its share class
+ * ("Alphabet Inc.", not "Alphabet Inc. Class A Common Stock"): its primary US
+ * common stock where exchanges reuse the symbol, else its US line. An
+ * untracked symbol has no local metadata to expand it, and its quote name
+ * never arrives for a fixed binding, so the shared instrument search is the
+ * only reliable expansion.
+ *
+ * Then the names of the covered issuers (`goodyear`, `GOODYEAR`, `paramount `
+ * are The Goodyear Tire & Rubber Company and Paramount Global), by words of
+ * three letters or more: `f` and `ge` go to the symbol they are. Only then a
+ * listing abroad with that exact symbol, and only when it names a covered
+ * issuer: Goodyear India, the first hit for `goodyear`, is no CDS name. Last,
+ * the primary US common stock with the symbol, or the first one whose name
+ * carries what was typed. Nothing matched, the input goes to the tape as
+ * typed, with the covered issuers closest to it.
+ *
+ * A longer name in capitals and lowercase is already a company name and is
+ * sent as written. A search outage falls back to the raw input rather than
+ * taking the CDS request down with it.
+ */
+async function resolveCdsIssuer(
+  query: string,
+  searchInstruments: InstrumentSearch,
+  coveredIssuers: CoveredIssuers = defaultCoveredIssuers,
+): Promise<CdsIssuerResolution> {
+  const ticker = TICKER_LIKE.test(query);
+  const oneWord = !/\s/.test(query);
+  if (!oneWord && query !== query.toLowerCase()) return { issuer: issuerNameOf(query), unmatched: null };
+  const referenceEntity = oneWord ? cdsReferenceEntity(query) : null;
+  if (referenceEntity) return { issuer: referenceEntity, unmatched: null };
+  const symbol = query.toUpperCase();
+  let results: InstrumentSearchResult[] | null = null;
+  let abroad: InstrumentSearchResult | undefined;
+  if (ticker) {
+    results = await searchOrNone(searchInstruments, query);
+    const exactMatches = results.filter((result) => result.symbol.toUpperCase() === symbol);
+    const name = (exactMatches.find(isPrimaryUsCommonStock) ?? exactMatches.find(isUsLine))?.name?.trim();
+    if (name) return { issuer: issuerNameOf(name), unmatched: null };
+    abroad = exactMatches.find((result) => !!result.name?.trim());
+  }
+  const covered = await coveredOrNone(coveredIssuers);
+  const named = coveredIssuerMatch(query, covered);
+  if (named) return { issuer: named, unmatched: null };
+  // A line abroad never wins on its own: only as the covered issuer it names.
+  const abroadIssuer = abroad ? coveredIssuerMatch(issuerNameOf(abroad.name.trim()), covered) : null;
+  if (abroadIssuer) return { issuer: abroadIssuer, unmatched: null };
+  results ??= await searchOrNone(searchInstruments, query);
+  const primary = results.filter(isPrimaryUsCommonStock);
+  const listing = (primary.find((result) => result.symbol.toUpperCase() === symbol) ?? primary.find((result) => carriesTyped(result, query)))?.name?.trim();
+  if (listing) {
+    const issuer = issuerNameOf(listing);
+    const listed = coveredIssuerMatch(issuer, covered);
+    return listed
+      ? { issuer: listed, unmatched: null }
+      : { issuer, unmatched: { nearest: closestCoveredIssuers(query, covered) } };
+  }
+  return { issuer: ticker ? query : issuerNameOf(query), unmatched: { nearest: closestCoveredIssuers(query, covered) } };
+}
+
+/** The name `resolveCdsIssuer` sends to the tape, for a caller that only needs that. */
 export async function resolveIssuerName(
   issuer: string,
   searchInstruments: InstrumentSearch,
+  coveredIssuers?: CoveredIssuers,
 ): Promise<string> {
-  if (!TICKER_LIKE.test(issuer)) return issuerNameOf(issuer);
-  const referenceEntity = cdsReferenceEntity(issuer);
-  if (referenceEntity) return referenceEntity;
-  try {
-    const results = await searchInstruments(issuer);
-    const symbol = issuer.toUpperCase();
-    const exactMatches = results.filter((result) => result.symbol.toUpperCase() === symbol);
-    const match = exactMatches.find(isPrimaryUsCommonStock) ?? exactMatches[0] ?? results[0];
-    const name = match?.name?.trim();
-    return name ? issuerNameOf(name) : issuer;
-  } catch {
-    return issuer;
-  }
+  return (await resolveCdsIssuer(issuer, searchInstruments, coveredIssuers)).issuer;
 }
 
 export async function loadCdsActivity(
   issuer: string | null,
   fetchCds: CdsFetch = (params) => apiClient.getCloudCds(params),
   searchInstruments: InstrumentSearch = (query, limit) => apiClient.searchInstruments(query, limit),
+  coveredIssuers: CoveredIssuers = defaultCoveredIssuers,
 ): Promise<CdsActivity> {
   const query = issuer?.trim() || null;
-  const resolved = query ? await resolveIssuerName(query, searchInstruments) : null;
+  const resolved = query ? await resolveCdsIssuer(query, searchInstruments, coveredIssuers) : null;
   const response = await fetchCds({
-    ...(resolved ? { issuer: resolved } : {}),
+    ...(resolved ? { issuer: resolved.issuer } : {}),
     days: CDS_TRADE_DAYS,
     limit: CDS_TRADE_LIMIT,
   });
@@ -100,7 +211,8 @@ export async function loadCdsActivity(
     source: response.source,
     asOf: response.asOf,
     query,
-    issuer: resolved,
+    issuer: resolved?.issuer ?? null,
+    ...(resolved?.unmatched ? { unmatched: resolved.unmatched } : {}),
     days: CDS_TRADE_DAYS,
     trades: normalizeCdsTrades(response.trades ?? []),
   };

package/src/plugins/builtin/cds/headless.ts

@@ -9,6 +9,7 @@ import type {
 } from "../../../types/plugin";
 import {
   CDS_TRADE_DAYS,
+  coveredIssuersFrom,
   loadCdsActivity,
   loadCdsSpreadHistory,
   loadCdsSpreadLevels,
@@ -17,6 +18,7 @@ import {
   type CdsHistoryFetch,
   type CdsLevelsFetch,
   type CdsSpreadHistory,
+  type CoveredIssuers,
   type InstrumentSearch,
 } from "./client";
 import { formatContract } from "../credit-boards/model";
@@ -35,6 +37,7 @@ import {
   formatSpreadMove,
   formatSpreadRange,
   formatUpfront,
+  hasPointsQuotes,
   issuerListSort,
   quotedLevel,
   lastTradeOf,
@@ -154,7 +157,7 @@ function tradeForFormatting(row: Record<string, unknown>): CdsTrade {
   return row as unknown as CdsTrade;
 }
 
-const TRADE_COLUMNS = [
+const TRADE_COLUMNS: HeadlessPaneColumn[] = [
   { key: "eventAt", header: "Time UTC", shrink: false, format: (value: unknown) => formatEventTime(Number(value)) },
   { key: "issuer", header: "Issuer" },
   { key: "maturity", header: "Maturity" },
@@ -175,6 +178,22 @@ const TRADE_COLUMNS = [
   },
 ];
 
+/**
+ * A print that quoted points upfront in its spread field reads in a Points
+ * column, shown when one did; exports write the number as quoted.
+ */
+const POINTS_COLUMN: HeadlessPaneColumn = {
+  key: "pointsUpfront",
+  header: "Points",
+  align: "right",
+  format: (value: unknown) => (typeof value === "number" ? String(value) : "--"),
+  textFormat: (value: unknown) => formatPoints(numberOrNull(value)),
+};
+
+const tradeColumns = (points: boolean): HeadlessPaneColumn[] => (
+  points ? [...TRADE_COLUMNS.slice(0, -1), POINTS_COLUMN, TRADE_COLUMNS.at(-1)!] : TRADE_COLUMNS
+);
+
 /**
  * The pane's figures over its 5Y chart, as label and value lines: the level,
  * its date, the 1W and 1M moves through the roll and the range charted, in
@@ -227,24 +246,29 @@ interface CdsReportInputs {
 function projectCdsHeadless({ activity, history, levels, sort, days = DAILY_DAYS.defaultValue }: CdsReportInputs): HeadlessBundleResult {
   const errors: string[] = [];
   const notes: string[] = [];
-  const empty = noTradesMessage({ query: activity.query, issuer: activity.issuer, days: activity.days });
   const metadata = { issuer: activity.issuer, days: activity.days };
   if (activity.query) {
     const line = history instanceof Error || !history ? null : history;
     if (history instanceof Error) errors.push("5Y spread history unavailable.");
+    // A name that matched no covered issuer, with no trades and no line under it on the tape either.
+    const unmatched = activity.unmatched && !activity.trades.length && line && !line.issuer ? activity.unmatched : null;
+    const empty = noTradesMessage({ query: activity.query, issuer: activity.issuer, days: activity.days, unmatched });
     const entries = line ? spreadEntries(line) : [];
-    // The name the tape was queried for heads the figures, as in the pane, so a ticker says what it became.
-    const name = displayIssuerName(activity.issuer ?? line?.issuer ?? activity.query);
+    // The name the tape was queried for heads the figures, as in the pane, so a ticker says what it became;
+    // a name sent as typed takes the one the tape answered with.
+    const name = displayIssuerName((activity.unmatched ? line?.issuer : null) ?? activity.issuer ?? line?.issuer ?? activity.query);
     const why = line ? noLevelMessage(line.noLevelReason, line.points.at(-1)?.date ?? null) : null;
     if (why) notes.push(`${why}.`);
-    else if (line && entries.length === 0) notes.push(`No 5Y spread level for ${name} in the last two years.`);
+    else if (unmatched) {
+      if (!unmatched.nearest.length) notes.push("fn CDS lists the covered issuers.");
+    } else if (line && entries.length === 0) notes.push(`No 5Y spread level for ${name} in the last two years.`);
     // The 5Y figures are dated by their level's day, each trade and each daily level by its own.
     const levelDate = line ? spreadSummary(line)?.date : undefined;
     const sections: HeadlessBundleSection[] = [
       ...(entries.length ? [{ title: name, entries, symbol: name, ...(levelDate ? { asOf: levelDate } : {}) }] : []),
       {
         title: "Trades",
-        columns: TRADE_COLUMNS,
+        columns: tradeColumns(hasPointsQuotes(activity.trades)),
         rows: sortTrades(activity.trades, DEFAULT_TRADE_SORT).map((trade) => ({ ...trade })),
         empty,
         rowSymbolKey: "issuer",
@@ -265,6 +289,7 @@ function projectCdsHeadless({ activity, history, levels, sort, days = DAILY_DAYS
       ...(notes.length ? { notes } : {}),
     };
   }
+  const empty = noTradesMessage({ query: null, issuer: null, days: activity.days });
   if (levels instanceof Error) errors.push("5Y spreads unavailable.");
   const issuers = withSpreadLevels(summarizeIssuers(activity.trades), levels instanceof Error ? null : levels ?? null);
   return {
@@ -294,14 +319,15 @@ export interface CdsHeadlessDependencies {
     issuer: string | null,
     fetchCds: CdsFetch,
     searchInstruments: InstrumentSearch,
+    coveredIssuers: CoveredIssuers,
   ): Promise<CdsActivity>;
   loadHistory?(issuer: string, fetchHistory: CdsHistoryFetch): Promise<CdsSpreadHistory>;
   loadLevels?: typeof loadCdsSpreadLevels;
 }
 
 const defaultDependencies: CdsHeadlessDependencies = {
-  load: (_args, issuer, fetchCds, searchInstruments) => (
-    loadCdsActivity(issuer, fetchCds, searchInstruments)
+  load: (_args, issuer, fetchCds, searchInstruments, coveredIssuers) => (
+    loadCdsActivity(issuer, fetchCds, searchInstruments, coveredIssuers)
   ),
   loadHistory: (issuer, fetchHistory) => loadCdsSpreadHistory(issuer, fetchHistory),
   loadLevels: loadCdsSpreadLevels,
@@ -353,6 +379,7 @@ export function createCdsHeadless(
         issuer,
         (params) => ctx.apiClient.getCloudCds(params),
         (query, limit) => ctx.apiClient.searchInstruments(query, limit),
+        coveredIssuersFrom(fetchLevels),
       );
       if (activity.query) {
         // The line follows the name the tape was queried for, as the pane's does.