fullstackgtm 0.53.1 → 0.55.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullstackgtm",
-  "version": "0.53.1",
+  "version": "0.55.0",
   "description": "Open-source agentic GTM ops framework: canonical GTM data model, pluggable deterministic audits, reviewable dry-run patch plans, approval-gated write-back with conflict detection, and cross-system entity resolution. HubSpot, Salesforce, and Stripe connectors included.",
   "license": "Apache-2.0",
   "author": "Full Stack GTM LLC <ryan@fullstackgtm.com> (https://fullstackgtm.com)",

package/skills/fullstackgtm/SKILL.md

@@ -64,7 +64,7 @@ credentials AND stored plans per client org.
 | `call parse\|score\|link\|plan` | Transcripts → evidence-quoted insights, rubric scorecards, deal linking, governed next-step writes |
 | `enrich append\|refresh\|ingest\|status` | Governed enrichment (Apollo pull / Clay ingest), fill-blanks-only plans |
 | `enrich acquire [--source explorium\|pipe0\|linkedin] [--max <new>] [--scan-limit <raw>]` | Net-new ICP-targeted lead gen: independent per-provider/list/query checkpoints traverse full audiences instead of rereading page one; paired CLIs CAS-sync opaque, non-PII continuation to the hosted org; resolve-first deduped `create_record` plans, meter-capped and owner-stamped; `enrich status --runs` exposes funnel + continuation; never auto-writes |
-| `signals fetch\|list\|outcome\|weights` | Detect-side timing layer: capture fresh buying triggers into a profile-scoped ledger (free Greenhouse/Lever/Ashby ATS in the box; `--from` staged files; `--connector file\|serpapi-news\|hubspot-forms` to pull connected platforms / read the webhook spool `<home>/signals/spool`, secrets via the credential ladder), ranked by learned weights. Writes NOTHING to the CRM; `outcome --account <domain> --contact <id> --result …` re-weights which triggers earn a touch |
+| `signals fetch\|discover\|list\|outcome\|weights` | Detect-side timing layer: capture fresh buying triggers into a profile-scoped ledger (free Greenhouse/Lever/Ashby watchlist scans; Exa-backed ICP behavioral evidence discovery; `--from` staged files; `--connector file\|serpapi-news\|hubspot-forms` to pull connected platforms / read the webhook spool `<home>/signals/spool`, secrets via the credential ladder), ranked by learned weights. Writes NOTHING to the CRM; `outcome --account <domain> --contact <id> --result …` re-weights which triggers earn a touch |
 | `icp interview\|set\|show\|judge\|eval` | Build the ICP, then `judge` ranks fresh signals into send/nurture/skip — pass a snapshot (`--provider`/`--input`) and each decision resolves its CRM target (`accountId` + the `contact`/`contacts` to reach). `eval` is the calibration gate (exit 2 below the bar) |
 | `draft [--from-judge latest] [--channel email\|linkedin\|task]` | One trigger-grounded opener per hot account → a governed `create_task` targeting the resolved `contact.id` (or `accountId`); rejects a domain-only decision ("acquire it first"). **Never sends** — after `plans approve`, `apply --provider <crm>` logs it as a CRM task, or `apply --channel outbox` renders it to `<home>/signals/outbox/<channel>.jsonl` for a downstream sender to drain; the CLI transmits nothing |
 | `market init\|capture\|classify\|worksheet\|observe\|fronts\|axes\|overlay\|scale\|report\|refresh` | Competitive category map; evidence quotes verified verbatim against stored captures |

package/src/cli/auth.ts

@@ -399,7 +399,7 @@ export async function login(args: string[]) {
     console.log(`Stored Clay Public API key in ${credentialsPath()}. Clay connector commands resolve it automatically.`);
     return;
   }
-  if (provider === "pipe0" || provider === "explorium" || provider === "heyreach" || provider === "theirstack") {
+  if (provider === "pipe0" || provider === "explorium" || provider === "heyreach" || provider === "theirstack" || provider === "exa") {
     rejectArgvSecret(args, "--token", "--key", "--api-key");
     const key = await readSecret(`${provider} API key`);
     if (!key) throw new Error(`No ${provider} key provided.`);
@@ -408,13 +408,14 @@ export async function login(args: string[]) {
     const stamp = new Date().toISOString();
     storeCredential(provider, { kind: "api_key", accessToken: key, createdAt: stamp, updatedAt: stamp });
     const usedBy =
-      provider === "theirstack" ? "`fullstackgtm tam estimate --source theirstack`" : "`fullstackgtm enrich acquire`";
+      provider === "theirstack" ? "`fullstackgtm tam estimate --source theirstack`" :
+      provider === "exa" ? "`fullstackgtm signals discover`" : "`fullstackgtm enrich acquire`";
     console.log(`Stored ${provider} API key in ${credentialsPath()}. ${usedBy} uses it automatically (validated on first pull).`);
     return;
   }
   if (provider !== "hubspot") {
     throw new Error(
-      "login supports: hubspot, salesforce, stripe, anthropic, openai, openrouter, apollo, clay, pipe0, explorium, heyreach, theirstack, or --via <hosted url>. Usage: fullstackgtm login <provider> | fullstackgtm login --via https://gtm.example.com",
+      "login supports: hubspot, salesforce, stripe, anthropic, openai, openrouter, apollo, clay, pipe0, explorium, heyreach, theirstack, exa, or --via <hosted url>. Usage: fullstackgtm login <provider> | fullstackgtm login --via https://gtm.example.com",
     );
   }
   const now = new Date().toISOString();

package/src/cli/enrich.ts

@@ -9,7 +9,7 @@ import { createFilePlanStore } from "../planStore.ts";
 import { buildAcquirePlan, buildEnrichPlan, createFileEnrichRunStore, DEFAULT_STALE_DAYS, ENRICH_CONFIG_FILE_NAME, builtinAcquirePreset, builtinEnrichPreset, enrichRunId, inferIngestObjectType, latestStamps, loadEnrichConfig, parseCsv, resolveCrmField, selectStaleWork, stagedSourceRecords, staleDaysFor, type EnrichConfig, type EnrichCounts, type EnrichObjectType, type EnrichRun, type EnrichRunStore, type EnrichSourceRecord } from "../enrich.ts";
 import { loadMeter, remaining, type AcquireRemaining } from "../acquireMeter.ts";
 import { crmContactKeys, fetchExploriumProspects, fetchPipe0CrustdataProspectPage, partitionFreshProspects, pipe0ResolveCompanyDomains, pipe0ResolveWorkEmails, prospectIdentityKeys, type Prospect } from "../connectors/prospectSources.ts";
-import { createClaySearch, runClayPeopleSearchPage } from "../connectors/clay.ts";
+import { createClaySearch, discoverClayInvestmentProspects, runClayPeopleSearchPage } from "../connectors/clay.ts";
 import { runContactWaterfall, type ContactProviderAdapter, type ContactWaterfallStep } from "../contactProviders.ts";
 import { loadSeen, recordSeen } from "../acquireSeen.ts";
 import { acquireCheckpointId, createFileAcquireCheckpointStore, type AcquireCheckpointKey } from "../acquireCheckpoint.ts";
@@ -18,14 +18,14 @@ import { uploadHostedPatchPlan } from "../hostedPatchPlan.ts";
 import { progressReporter, reportCounts, reportEvent } from "../runReport.ts";
 import { ACQUIRE_STAGES, composeListeners, createProgressEmitter } from "../progress.ts";
 import { createLinkedInProvider, discoverLinkedInProspects } from "../acquireLinkedIn.ts";
-import { clayPeopleFilterRoutes, fitThreshold, icpToClayPeopleFilters, icpToCrustdataFilters, icpToExploriumFilters, scoreProspectAgainstIcp, type Icp } from "../icp.ts";
+import { clayPeopleFilterRoutes, fitThreshold, icpToClayInvestmentCompanyFilters, icpToClayPeopleFilters, icpToCrustdataFilters, icpToExploriumFilters, scoreProspectAgainstIcp, type Icp } from "../icp.ts";
 import { apolloPullKeysForAppend, apolloPullKeysForRefresh, createApolloClient, pullApolloRecords, type ApolloPullKey } from "../enrichApollo.ts";
 import type { CanonicalGtmSnapshot, CreateRecordPayload } from "../types.ts";
 import { isSpoolPath, readSpoolPath } from "../spoolFiles.ts";
 import { isOptionValue, loadIcp, numericOption, option, readSnapshot, saveRequested } from "./shared.ts";
 import { providerKey } from "./tam.ts";
 import { unknownSubcommandError } from "./suggest.ts";
-import { box, colorEnabled, createProgressRenderer, createStatusLine, formatBar, formatDuration, paint, truncateToWidth, type Paint } from "./ui.ts";
+import { box, colorEnabled, createProgressRenderer, createStatusLine, formatBar, formatDuration, paint, scoreColor, truncateToWidth, type Paint } from "./ui.ts";
 import { compactPlan, verbosePlanRequested } from "./planOutput.ts";
 import type { AcquireBudget } from "../acquireMeter.ts";
 
@@ -674,6 +674,19 @@ async function acquireFromApi(
       cursor = result.nextCursor;
       exhausted = result.nextCursor === null;
     } else if (disc.provider === "clay") {
+      if (icp?.motion === "investment") {
+        const companyFilters = icpToClayInvestmentCompanyFilters(icp);
+        progress.note("searching Clay companies against the investment thesis");
+        const result = await discoverClayInvestmentProspects({
+          apiKey: providerKey("clay"), companyFilters,
+          titleKeywords: icp.persona.titleKeywords ?? ["Founder", "Co-founder", "CEO", "CTO"],
+          companyLimit: Math.min(scanLimit - discovered, 25), prospectLimit: requestSize,
+        });
+        page = result.prospects;
+        progress.note(`${result.companiesScanned} target account(s) scanned · resolving founders`);
+        exhausted = true;
+        cursor = "investment-account-first";
+      } else {
       while (true) {
         if (!cursor) {
           const route = clayRoutes[clayRouteIndex];
@@ -694,6 +707,7 @@ async function acquireFromApi(
         offset = 0;
         exhausted = false;
       }
+      }
     } else if (disc.provider === "explorium") {
       const pageNumber = offset + 1;
       exploriumPage = pageNumber;
@@ -932,12 +946,14 @@ function renderAcquireLeadCards(result: ReturnType<typeof buildAcquirePlan>): st
     let fit: number | undefined;
     const item = operation.evidenceIds?.[0] ? evidence.get(operation.evidenceIds[0]) : undefined;
     try { fit = Number((JSON.parse(item?.text ?? "{}") as { fitScore?: unknown }).fitScore); } catch { /* malformed evidence remains display-only */ }
+    const fitPercent = Number.isFinite(fit) ? Math.round((fit ?? 0) * 100) : undefined;
     const lines = [
-      truncateToWidth(name, 84),
-      truncateToWidth(`${title} · ${company}`, 84),
-      truncateToWidth([payload.associateCompanyDomain, props.hs_linkedin_url].filter(Boolean).join(" · "), 84),
+      p.bold(truncateToWidth(name, 84)),
+      p.cyan(truncateToWidth(`${title} · ${company}`, 84)),
+      p.blue(truncateToWidth([payload.associateCompanyDomain, props.hs_linkedin_url].filter(Boolean).join(" · "), 84)),
     ];
-    return box(lines, p, `Lead ${index + 1}/${result.plan.operations.length}${Number.isFinite(fit) ? ` · ${Math.round((fit ?? 0) * 100)}% fit` : ""}`).join("\n");
+    const fitLabel = fitPercent === undefined ? "" : ` · ${scoreColor(fitPercent, p)}% fit`;
+    return box(lines, p, `Lead ${index + 1}/${result.plan.operations.length}${fitLabel}`).join("\n");
   }).join("\n");
 }
 

package/src/cli/help.ts

@@ -21,9 +21,9 @@ Usage:
   fullstackgtm login stripe [--no-validate]
   fullstackgtm login anthropic | openai        store an LLM API key for call parse/score
   fullstackgtm login apollo | clay             store a data-provider Public API key
-  fullstackgtm login pipe0 | explorium | theirstack  store a discovery-provider key (theirstack = technographic TAM)
+  fullstackgtm login pipe0 | explorium | theirstack | exa  store a discovery-provider key
   fullstackgtm login heyreach                  store a HeyReach key for enrich acquire --source linkedin
-  fullstackgtm logout <hubspot|salesforce|stripe|anthropic|openai|apollo|clay|pipe0|explorium|heyreach|broker>
+  fullstackgtm logout <hubspot|salesforce|stripe|anthropic|openai|apollo|clay|pipe0|explorium|theirstack|exa|heyreach|broker>
 
   Secrets (tokens, client secrets) are NEVER passed as flags — they leak via
   the process list and shell history. Pipe them on stdin or enter them at the
@@ -105,10 +105,12 @@ Usage:
                                                in the same plan (freemail domains never used;
                                                --skip-unmatched = report-only). HubSpot-only for now.
   fullstackgtm signals fetch [--bucket job,…] [--source greenhouse,lever,ashby] [--watchlist <path|crm:seg>] [--keywords …] [--from <file.json|spool.jsonl|spool-dir>] [--save]
+  fullstackgtm signals discover [--icp <path>] [--source exa] [--since 30d] [--max-accounts 10] [--max-results 50] [--max-searches 12] [--max-usd 0.25] [--save]
   fullstackgtm signals list [--since 7d] [--bucket b] [--account d] [--unjudged]
   fullstackgtm signals outcome --account <d> [--touch <id>] --result replied|meeting|bounced|no_reply
   fullstackgtm signals weights [--explain]
-                                               detect fresh buying triggers (ATS hiring scrapes + staged
+                                               detect fresh buying triggers (ICP-driven evidence discovery,
+                                               ATS hiring scans, and staged
                                                funding/company/social ingest), rank them, persist a local
                                                signal ledger. READ-ONLY re: CRM — fetch NEVER emits a plan;
                                                --save persists only the signal ledger. outcome feeds the
@@ -324,7 +326,7 @@ export const HELP: Record<string, HelpEntry> = {
   logout: {
     summary: "remove stored credentials for a provider",
     phase: "Setup",
-    synopsis: ["fullstackgtm logout <hubspot|salesforce|stripe|anthropic|openai|apollo|clay|pipe0|explorium|broker>"],
+    synopsis: ["fullstackgtm logout <hubspot|salesforce|stripe|anthropic|openai|apollo|clay|pipe0|explorium|theirstack|exa|broker>"],
     seeAlso: ["login", "doctor"],
   },
   doctor: {
@@ -622,12 +624,13 @@ export const HELP: Record<string, HelpEntry> = {
     phase: "Detect",
     synopsis: [
       "fullstackgtm signals fetch [--bucket job,…] [--source greenhouse,lever,ashby] [--connector file,serpapi-news,hubspot-forms] [--connector-opt k=v] [--watchlist <path|crm:seg>] [--keywords …] [--from <file.json|spool.jsonl|spool-dir>] [--save]",
+      "fullstackgtm signals discover [--icp <path>] [--source exa] [--since 30d] [--max-accounts 10] [--max-results 50] [--max-searches 12] [--max-usd 0.25] [--save]",
       "fullstackgtm signals list [--since 7d] [--bucket b] [--account d] [--unjudged]",
       "fullstackgtm signals outcome --account <d> [--touch <id>] --result replied|meeting|bounced|no_reply",
       "fullstackgtm signals weights [--explain]",
     ],
     detail:
-      "Read-only re: CRM — `fetch` NEVER emits a patch plan; `--save` persists only the local signal ledger. ATS adapters are no-auth; source connectors (`--connector`) pull from connected platforms with secrets via the credential ladder, never argv. `outcome` feeds the learned per-bucket `weights`.",
+      "Read-only re: CRM — `fetch` and `discover` NEVER emit a patch plan; `--save` persists only the local signal ledger. `discover` matches ICP behavioral hypotheses against canonical public ATS evidence through Exa, with explicit request and reported-cost budgets. Secrets resolve through env/login, never argv. `outcome` feeds the learned per-bucket `weights`.",
     seeAlso: ["icp", "draft"],
   },
   icp: {
@@ -699,13 +702,13 @@ export const COMMAND_FLAGS: Record<string, string[]> = {
   market: ["--category", "--config", "--vendor", "--snapshot", "--task-account", "--task-deal", "--capture-run", "--run", "--prior-run", "--diff", "--from", "--calls", "--anchor", "--min-mentions", "--max-claims", "--promote-lift", "--model", "--format", "--auto", "--unverified", "--save", "--dry-run", "--verbose", "--json", "--out"],
   tam: [...SOURCE_FLAGS, "--source", "--name", "--icp", "--accounts", "--acv", "--acv-basis", "--acv-from-crm", "--deal-period", "--buyers-per-account", "--cross-checks", "--max", "--max-credits", "--usd-per-credit", "--dry-run", "--confirm", "--cron", "--label", "--save", "--verbose", "--json", "--out"],
   icp: [...SOURCE_FLAGS, "--name", "--icp", "--domain", "--no-interactive", "--signals-from", "--with-history", "--prompt", "--min-score", "--from-judge", "--golden", "--against-outcomes", "--min-accuracy", "--model", "--label", "--save", "--verbose", "--json", "--out"],
-  signals: ["--bucket", "--source", "--connector", "--connector-opt", "--watchlist", "--keywords", "--from", "--label", "--since", "--account", "--contact", "--unjudged", "--touch", "--result", "--save", "--verbose", "--json", "--explain"],
+  signals: ["--bucket", "--source", "--connector", "--connector-opt", "--watchlist", "--keywords", "--from", "--label", "--since", "--icp", "--max-accounts", "--max-results", "--max-searches", "--max-usd", "--account", "--contact", "--unjudged", "--touch", "--result", "--save", "--verbose", "--json", "--explain"],
   draft: ["--from-judge", "--min-score", "--prompt", "--model", "--channel", "--save", "--dry-run", "--verbose", "--json", "--out"],
   schedule: ["--cron", "--label", "--provider", "--trigger", "--timer", "--runs", "--verbose", "--json"],
 };
 
 export const FLAGS_WITH_VALUES = new Set([
-  "--account", "--account-id", "--accounts", "--acv", "--acv-basis", "--after", "--anchor", "--api-key", "--approve", "--archive", "--assign-owner", "--attendees", "--before", "--bucket", "--buyers-per-account", "--call", "--call-type", "--calls", "--capture-run", "--category", "--channel", "--client", "--client-id", "--client-secret", "--config", "--connector", "--connector-opt", "--contact", "--cron", "--cross-checks", "--deal", "--deal-period", "--diff", "--domain", "--email", "--except-deal-stage", "--format", "--from", "--from-judge", "--golden", "--guard", "--icp", "--in", "--input", "--instance-url", "--keep", "--key", "--keywords", "--label", "--list", "--login-url", "--match", "--match-property", "--max", "--max-claims", "--max-credits", "--max-examples", "--max-operations", "--min-accuracy", "--min-confidence", "--min-mentions", "--min-score", "--model", "--name", "--objects", "--operations", "--out", "--pipeline", "--plan", "--plan-id", "--policy", "--port", "--prepared-by", "--prior-run", "--profile", "--promote-lift", "--prompt", "--provider", "--reason", "--require", "--result", "--rubric", "--rule", "--rules", "--run", "--run-label", "--runs", "--scan-limit", "--scopes", "--seed", "--set", "--signals-from", "--since", "--snapshot", "--source", "--staged-run", "--stale-days", "--status", "--task-account", "--task-deal", "--timer", "--title", "--to", "--today", "--token", "--token-env", "--touch", "--transcript", "--trigger", "--usd-per-credit", "--value", "--values-from", "--vendor", "--via", "--watchlist", "--where",
+  "--account", "--account-id", "--accounts", "--acv", "--acv-basis", "--after", "--anchor", "--api-key", "--approve", "--archive", "--assign-owner", "--attendees", "--before", "--bucket", "--buyers-per-account", "--call", "--call-type", "--calls", "--capture-run", "--category", "--channel", "--client", "--client-id", "--client-secret", "--config", "--connector", "--connector-opt", "--contact", "--cron", "--cross-checks", "--deal", "--deal-period", "--diff", "--domain", "--email", "--except-deal-stage", "--format", "--from", "--from-judge", "--golden", "--guard", "--icp", "--in", "--input", "--instance-url", "--keep", "--key", "--keywords", "--label", "--list", "--login-url", "--match", "--match-property", "--max", "--max-accounts", "--max-claims", "--max-credits", "--max-examples", "--max-operations", "--max-results", "--max-searches", "--max-usd", "--min-accuracy", "--min-confidence", "--min-mentions", "--min-score", "--model", "--name", "--objects", "--operations", "--out", "--pipeline", "--plan", "--plan-id", "--policy", "--port", "--prepared-by", "--prior-run", "--profile", "--promote-lift", "--prompt", "--provider", "--reason", "--require", "--result", "--rubric", "--rule", "--rules", "--run", "--run-label", "--runs", "--scan-limit", "--scopes", "--seed", "--set", "--signals-from", "--since", "--snapshot", "--source", "--staged-run", "--stale-days", "--status", "--task-account", "--task-deal", "--timer", "--title", "--to", "--today", "--token", "--token-env", "--touch", "--transcript", "--trigger", "--usd-per-credit", "--value", "--values-from", "--vendor", "--via", "--watchlist", "--where",
 ]);
 
 // Lifecycle-grouped front door. One line per verb, organized by the

package/src/cli/icp.ts

@@ -38,6 +38,10 @@ function updateReviewSegment(icp: Icp, id: string, raw: string): Icp {
   if (["titleKeywords", "jobLevels", "departments"].includes(id)) {
     return { ...icp, persona: { ...icp.persona, [id]: values } };
   }
+  if (["investmentStages", "fundingAmounts", "thesisKeywords"].includes(id)) {
+    const field = id === "investmentStages" ? "stages" : id;
+    return { ...icp, investment: { ...icp.investment, [field]: values } } as Icp;
+  }
   return { ...icp, signals: { ...icp.signals, intentTopics: values } };
 }
 

package/src/cli/signals.ts

@@ -3,11 +3,12 @@
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { getCredential, resolveHubspotConnection } from "../credentials.ts";
+import { discoverSignalsWithExa } from "../signalDiscovery.ts";
 import { buildSignalsFromAts, computeWeights, createFileSignalStore, DEFAULT_SIGNALS_CONFIG, dedupeSignals, loadSignalsConfig, makeOutcome, normalizeAccountDomain, SIGNAL_BUCKETS, signalRunId, signalsSpoolDir, stagedRowToSignal, type Signal, type SignalBucket, type SignalOutcomeResult, type SignalsConfig } from "../signals.ts";
 import { fetchAtsJobs, type AtsBoardSource, type AtsJob } from "../connectors/atsBoards.ts";
 import { getSignalSource, listSignalSources, type SignalSourceContext } from "../connectors/signalSources.ts";
 import { isSpoolPath, readSpoolPath } from "../spoolFiles.ts";
-import { option, readSnapshot, repeatedOption, saveRequested } from "./shared.ts";
+import { loadIcp, option, readSnapshot, repeatedOption, saveRequested } from "./shared.ts";
 import { createStatusLine } from "./ui.ts";
 import { unknownSubcommandError } from "./suggest.ts";
 
@@ -113,12 +114,15 @@ export async function signalsCommand(args: string[]) {
   if (!sub || args.includes("--help") || args.includes("-h")) {
     console.log(`Usage:
   fullstackgtm signals fetch [--bucket job,funding,...] [--source greenhouse,lever,ashby] [--connector file,serpapi-news,hubspot-forms] [--connector-opt k=v ...] [--watchlist <path|crm:segment>] [--keywords "growth,revops"] [--from <file.json|spool.jsonl|spool-dir>] [--config <path>] [--save]
+  fullstackgtm signals discover [--icp <path>] [--source exa] [--since 30d] [--max-accounts 10] [--max-results 50] [--max-searches 12] [--max-usd 0.25] [--save]
   fullstackgtm signals list [--since 7d] [--bucket b] [--account d] [--unjudged]
   fullstackgtm signals outcome --account <domain> [--touch <id>] --result replied|meeting|bounced|no_reply
   fullstackgtm signals weights [--explain]
 
-Detect fresh buying triggers and rank them. \`fetch\` is read-only re: CRM — it
-NEVER emits a patch plan; --save persists only the local signal ledger (used by
+Detect fresh buying triggers and rank them. \`discover\` searches canonical
+public ATS pages for evidence matching the ICP's behavioral trigger hypotheses,
+then resolves employer domains through Exa. \`fetch\` and \`discover\` are read-only re: CRM — they
+NEVER emit a patch plan; --save persists only the local signal ledger (used by
 \`icp judge\`). ATS adapters are no-auth. Source connectors (--connector) pull
 from connected platforms: file (local JSON/JSONL spool, no auth), serpapi-news
 (API key via env/login), hubspot-forms (reuses the HubSpot login). Secrets come
@@ -131,6 +135,54 @@ from the credential ladder, never argv; --connector-opt carries non-secret knobs
     return;
   }
 
+  if (sub === "discover") {
+    const source = option(rest, "--source") ?? "exa";
+    if (source !== "exa") throw new Error(`signals discover: unsupported --source "${source}" (currently: exa).`);
+    const icp = loadIcp(rest);
+    if (!icp) throw new Error("signals discover: no ICP found. Pass --icp <path> or create ./icp.json.");
+    const apiKey = await resolveSignalSourceKey("exa");
+    if (!apiKey) throw new Error("signals discover: missing Exa API key. Set EXA_API_KEY or run `fullstackgtm login exa`.");
+    const now = new Date();
+    const sinceArg = option(rest, "--since") ?? "30d";
+    const since = new Date(now.getTime() - parseSinceWindowMs(sinceArg));
+    const maxAccounts = positiveIntegerOption(rest, "--max-accounts", 10);
+    const maxResults = positiveIntegerOption(rest, "--max-results", 50);
+    const maxSearches = positiveIntegerOption(rest, "--max-searches", 12);
+    const maxUsd = positiveNumberOption(rest, "--max-usd", 0.25);
+    const config = resolveSignalsConfig(rest);
+    const status = createStatusLine();
+    status.set(`Searching public evidence with Exa… up to ${maxSearches} searches / $${maxUsd.toFixed(2)}`);
+    let discovered;
+    try {
+      discovered = await discoverSignalsWithExa({ icp, apiKey, since, maxAccounts, maxResults, maxSearches, maxUsd, now,
+        config });
+    } finally {
+      status.done();
+    }
+    const store = createFileSignalStore();
+    const priorSignals = await store.allSignals();
+    const { fresh, deduped } = dedupeSignals(discovered.signals, priorSignals, config.dedupWindowDays, now);
+    const ranked = [...fresh].sort((a, b) => b.weight - a.weight || a.accountDomain.localeCompare(b.accountDomain));
+    const output = { ...discovered.summary, freshSignals: ranked.length, dedupedSignals: deduped.length,
+      warnings: discovered.summary.warnings, signals: ranked };
+    console.log(rest.includes("--json") || rest.includes("--verbose") ? JSON.stringify(output, null, 2) : renderSignals(ranked));
+    console.error(
+      `Exa: ${discovered.summary.searchesUsed}/${maxSearches} searches, $${discovered.summary.costUsd.toFixed(4)} reported cost; ` +
+      `${discovered.summary.matchedEvidence} evidence match(es), ${discovered.summary.resolvedAccounts} account(s), ` +
+      `${ranked.length} fresh. NO plan emitted — discovery is read-only re: CRM.`,
+    );
+    for (const warning of discovered.summary.warnings) console.error(`Warning: ${warning}`);
+    if (saveRequested(rest)) {
+      const runLabel = option(rest, "--label") ?? `discover-${now.toISOString().slice(0, 10)}`;
+      await store.appendRun({ id: signalRunId(runLabel), runLabel, startedAt: now.toISOString(), completedAt: new Date().toISOString(),
+        buckets: ["job"], counts: { fetched: discovered.summary.rawResults, new: ranked.length, deduped: deduped.length }, signals: ranked });
+      console.error(`Saved signal run "${runLabel}". Next: \`fullstackgtm icp judge --signals-from ${runLabel} --save\`.`);
+    } else {
+      console.error("(not saved — re-run with --save to persist this evidence to the signal ledger)");
+    }
+    return;
+  }
+
   if (sub === "fetch") {
     const config = resolveSignalsConfig(rest);
     // Merge --keywords into the job bucket; filter buckets + job sources.
@@ -348,7 +400,23 @@ from the credential ladder, never argv; --connector-opt carries non-secret knobs
     return;
   }
 
-  throw unknownSubcommandError("signals", sub, ["fetch", "list", "outcome", "weights"]);
+  throw unknownSubcommandError("signals", sub, ["fetch", "discover", "list", "outcome", "weights"]);
+}
+
+function positiveIntegerOption(args: string[], flag: string, fallback: number): number {
+  const raw = option(args, flag);
+  if (raw == null) return fallback;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < 1) throw new Error(`${flag}: expected a positive integer (got "${raw}").`);
+  return value;
+}
+
+function positiveNumberOption(args: string[], flag: string, fallback: number): number {
+  const raw = option(args, flag);
+  if (raw == null) return fallback;
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value <= 0) throw new Error(`${flag}: expected a number greater than zero (got "${raw}").`);
+  return value;
 }
 
 /** Parse a "7d"/"30d"/"12h" recency window into milliseconds. */

package/src/cli/ui.ts

@@ -156,16 +156,16 @@ export function formatCount(value: number): string {
  */
 export function box(lines: string[], p: Paint, title?: string): string[] {
   const inner = Math.max(
-    ...lines.map((line) => line.length),
-    title ? title.length + 2 : 0,
+    ...lines.map((line) => stripAnsi(line).length),
+    title ? stripAnsi(title).length + 2 : 0,
   );
   const top = title
-    ? `╭─ ${title} ${"─".repeat(Math.max(0, inner - title.length - 1))}╮`
+    ? `╭─ ${title} ${"─".repeat(Math.max(0, inner - stripAnsi(title).length - 1))}╮`
     : `╭${"─".repeat(inner + 2)}╮`;
   const bottom = `╰${"─".repeat(inner + 2)}╯`;
   return [
     p.dim(top),
-    ...lines.map((line) => `${p.dim("│")} ${line.padEnd(inner)} ${p.dim("│")}`),
+    ...lines.map((line) => `${p.dim("│")} ${line}${" ".repeat(Math.max(0, inner - stripAnsi(line).length))} ${p.dim("│")}`),
     p.dim(bottom),
   ];
 }

package/src/connectors/clay.ts

@@ -17,6 +17,19 @@ export type ClayPeopleSearchPage = {
   hasMore: boolean;
 };
 
+export type ClayCompany = {
+  name?: string;
+  domain?: string;
+  linkedin?: string;
+  description?: string;
+  industry?: string;
+  size?: string;
+  location?: string;
+  fundingAmountRange?: string;
+};
+
+export type ClayCompanySearchPage = { companies: ClayCompany[]; hasMore: boolean };
+
 function clayHeaders(apiKey: string): Record<string, string> {
   return { "clay-api-key": apiKey, Accept: "application/json", "Content-Type": "application/json" };
 }
@@ -67,6 +80,74 @@ export async function runClayPeopleSearchPage(opts: {
   return { prospects: body.data.map(normalizeClayPerson), hasMore };
 }
 
+/** Consume the next company page from a Clay search iterator. */
+export async function runClayCompanySearchPage(opts: {
+  apiKey: string; searchId: string; limit?: number; fetchImpl?: typeof fetch; apiBaseUrl?: string;
+}): Promise<ClayCompanySearchPage> {
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const base = (opts.apiBaseUrl ?? CLAY_PUBLIC_API_BASE).replace(/\/$/, "");
+  const limit = Math.max(1, Math.min(opts.limit ?? 25, 100));
+  const response = await fetchImpl(`${base}/search/filters-mode/${encodeURIComponent(opts.searchId)}/run`, {
+    method: "POST", headers: clayHeaders(opts.apiKey), body: JSON.stringify({ limit }),
+  });
+  if (!response.ok) throw new ProviderHttpError("Clay", "run company search", response.status);
+  const body = await response.json() as { data?: unknown; has_more?: unknown; hasMore?: unknown };
+  if (!Array.isArray(body.data)) throw new Error("Clay company search returned an invalid data array.");
+  const hasMore = body.has_more ?? body.hasMore;
+  if (typeof hasMore !== "boolean") throw new Error("Clay company search returned no has_more flag.");
+  return { companies: body.data.map(normalizeClayCompany), hasMore };
+}
+
+export function normalizeClayCompany(value: unknown): ClayCompany {
+  const row = value && typeof value === "object" ? value as Record<string, unknown> : {};
+  return {
+    name: stringValue(row.name), domain: bareDomain(stringValue(row.domain)),
+    linkedin: normalizeLinkedin(stringValue(row.linkedin_url)), description: stringValue(row.description),
+    industry: stringValue(row.industry), size: stringValue(row.size), location: stringValue(row.location),
+    fundingAmountRange: stringValue(row.total_funding_amount_range_usd),
+  };
+}
+
+/** Account-first investment discovery: find thesis-shaped companies, then
+ * resolve founders/operators only inside those accounts. */
+export async function discoverClayInvestmentProspects(opts: {
+  apiKey: string;
+  companyFilters: Record<string, unknown>;
+  titleKeywords: string[];
+  companyLimit: number;
+  prospectLimit: number;
+  fetchImpl?: typeof fetch;
+  apiBaseUrl?: string;
+}): Promise<{ prospects: Prospect[]; companiesScanned: number; companiesMatched: ClayCompany[] }> {
+  const companySearchId = await createClaySearch({
+    apiKey: opts.apiKey, sourceType: "companies", filters: opts.companyFilters,
+    fetchImpl: opts.fetchImpl, apiBaseUrl: opts.apiBaseUrl,
+  });
+  const companyPage = await runClayCompanySearchPage({
+    apiKey: opts.apiKey, searchId: companySearchId, limit: opts.companyLimit,
+    fetchImpl: opts.fetchImpl, apiBaseUrl: opts.apiBaseUrl,
+  });
+  const prospects: Prospect[] = [];
+  const identifiers = companyPage.companies.map((company) => company.domain ?? company.linkedin).filter((value): value is string => Boolean(value));
+  if (identifiers.length > 0) {
+    const peopleSearchId = await createClaySearch({
+      apiKey: opts.apiKey, sourceType: "people",
+      filters: { company_identifier: identifiers, job_title_keywords: opts.titleKeywords },
+      fetchImpl: opts.fetchImpl, apiBaseUrl: opts.apiBaseUrl,
+    });
+    const peoplePage = await runClayPeopleSearchPage({
+      apiKey: opts.apiKey, searchId: peopleSearchId,
+      limit: opts.prospectLimit,
+      fetchImpl: opts.fetchImpl, apiBaseUrl: opts.apiBaseUrl,
+    });
+    // company_identifier may match a past experience. Investment discovery is
+    // explicitly account-first, so retain only people currently at an account.
+    const currentDomains = new Set(companyPage.companies.map((company) => company.domain).filter(Boolean));
+    prospects.push(...peoplePage.prospects.filter((person) => person.companyDomain && currentDomains.has(person.companyDomain)));
+  }
+  return { prospects, companiesScanned: companyPage.companies.length, companiesMatched: companyPage.companies };
+}
+
 export function normalizeClayPerson(value: unknown): Prospect {
   const row = value && typeof value === "object" ? value as Record<string, unknown> : {};
   const location = row.structured_location && typeof row.structured_location === "object"

package/src/icp.ts

@@ -13,8 +13,36 @@
  * Zero runtime deps; pure functions (translation + scoring take plain data).
  */
 
+export type TriggerHypothesis = {
+  /** Stable, human-editable key used to trace discovered evidence back to the ICP. */
+  id: string;
+  /** Observable business condition, e.g. "sales compensation process is breaking". */
+  label: string;
+  /** Phrases or concepts that count as supporting public evidence. */
+  positiveEvidence: string[];
+  /** Concrete projects/roles that often expose the condition. */
+  activeProjects?: string[];
+  /** Functions likely to own or feel the problem. */
+  buyerFunctions?: string[];
+  /** Terms that make a result a likely false positive. */
+  negativeEvidence?: string[];
+  /** Preferred public source classes. Discovery currently implements `job`. */
+  preferredSources?: Array<"job" | "news" | "company" | "social" | "review" | "legal">;
+};
+
 export type Icp = {
   name: string;
+  /** `investment` means the organization is sourcing companies to invest in,
+   * not conventional customers. Discovery becomes company-first, then resolves
+   * founders at the matched accounts. */
+  motion?: "sales" | "investment";
+  investment?: {
+    stages?: Array<"pre-seed" | "seed" | "series-a" | "series-b" | "growth" | "bootstrapped">;
+    /** Clay's native funding bands. */
+    fundingAmounts?: Array<"under_1m" | "1m_5m" | "5m_10m" | "10m_25m" | "25m_50m" | "50m_100m" | "100m_250m" | "over_250m" | "unknown">;
+    /** Terms expected in an investment target's company description. */
+    thesisKeywords?: string[];
+  };
   firmographics: {
     /** human industry labels, e.g. ["software","saas"] — used for keyword/industry filters */
     industries?: string[];
@@ -37,7 +65,11 @@ export type Icp = {
     /** the title phrases that DEFINE the buyer — also the scoring signal */
     titleKeywords?: string[];
   };
-  signals?: { intentTopics?: string[] };
+  signals?: {
+    intentTopics?: string[];
+    /** Testable behavioral hypotheses for evidence-first account discovery. */
+    triggerHypotheses?: TriggerHypothesis[];
+  };
   scoring?: {
     /** minimum fit (0..1) for a prospect to become a create_record op. Default 0.5. */
     threshold?: number;
@@ -66,9 +98,39 @@ export function parseIcp(raw: string): Icp {
   if (!icp.persona || (!icp.persona.titleKeywords?.length && !icp.persona.jobLevels?.length)) {
     throw new Error('icp: "persona" needs at least titleKeywords or jobLevels (without them, scoring cannot rank fit)');
   }
+  if (icp.motion === "investment" && !icp.investment?.thesisKeywords?.length && !icp.firmographics.industries?.length) {
+    throw new Error('icp: investment motion needs investment.thesisKeywords or firmographics.industries');
+  }
   return icp;
 }
 
+const CLAY_COMPANY_SIZE: Record<string, string> = {
+  // Clay's company enum is the lower boundary of its displayed bucket:
+  // 2 => 2-10, 10 => 11-50, 50 => 51-200, etc. Bucket `1` is one employee.
+  "1-10": "2", "11-50": "10", "51-200": "50", "201-500": "200",
+  "501-1000": "500", "1001-5000": "1000", "5001-10000": "5000", "10001+": "10000",
+};
+
+/** Native Clay company filters for an investment thesis. */
+export function icpToClayInvestmentCompanyFilters(icp: Icp): Record<string, unknown> {
+  const filters: Record<string, unknown> = {};
+  const sizes = [...new Set((icp.firmographics.employeeBands ?? []).map((band) => CLAY_COMPANY_SIZE[band.replace(/,/g, "")]).filter(Boolean))];
+  if (sizes.length) filters.sizes = sizes;
+  if (icp.investment?.fundingAmounts?.length) filters.funding_amounts = icp.investment.fundingAmounts;
+  if (icp.investment?.thesisKeywords?.length) filters.description_keywords = icp.investment.thesisKeywords;
+  const industries = [...new Set((icp.firmographics.industries ?? []).flatMap((industry) => CLAY_INDUSTRY[industry.toLowerCase()] ?? []))];
+  if (industries.length) filters.industries = industries;
+  return filters;
+}
+
+/** People filters used only after an investment target account has matched. */
+export function clayInvestmentPeopleFilters(icp: Icp, companyIdentifier: string): Record<string, unknown> {
+  return {
+    company_identifier: [companyIdentifier],
+    job_title_keywords: icp.persona.titleKeywords?.length ? icp.persona.titleKeywords : ["Founder", "Co-founder", "CEO", "CTO"],
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Discovery-filter translation
 
@@ -352,6 +414,30 @@ function titleCase(value: string): string {
 
 export type IcpFit = { score: number; reasons: string[] };
 
+function inferredLevel(title: string): string {
+  if (/\b(chief|ceo|cfo|coo|cto|cio|cmo|cro)\b/.test(title)) return "cxo";
+  if (/\b(vp|vice president)\b/.test(title)) return "vp";
+  if (/\b(head|general manager|gm)\b/.test(title)) return "head";
+  if (/\bdirector\b/.test(title)) return "director";
+  if (/\bmanager\b/.test(title)) return "manager";
+  if (/\b(founder|owner|partner)\b/.test(title)) return "owner";
+  return "";
+}
+
+function inferredDepartment(title: string): string {
+  const aliases: Array<[string, RegExp]> = [
+    ["operations", /\b(operations|ops|revops|gtm)\b/],
+    ["sales", /\b(sales|revenue|commercial)\b/],
+    ["marketing", /\b(marketing|growth|demand generation|brand)\b/],
+    ["creative", /\b(creative|content|design)\b/],
+    ["media", /\b(media|advertising)\b/],
+    ["engineering", /\b(engineering|developer|technical)\b/],
+    ["product", /\bproduct\b/],
+    ["finance", /\b(finance|financial)\b/],
+  ];
+  return aliases.find(([, pattern]) => pattern.test(title))?.[0] ?? "";
+}
+
 /**
  * Score a prospect's PERSONA fit 0..1. Title-keyword match is the strongest
  * signal (it's what defines the buyer); job level and department add to it.
@@ -376,26 +462,30 @@ export function scoreProspectAgainstIcp(
 
   if (keywords.length) {
     weightSum += 0.6;
-    const hit = keywords.find((k) => title.includes(k)) ?? roleKeywords(icp).find((keyword) => title.includes(keyword));
-    if (hit) {
+    const exact = keywords.find((k) => title.includes(k));
+    const functional = exact ? undefined : roleKeywords(icp).find((keyword) => title.includes(keyword));
+    if (exact) {
       score += 0.6;
-      reasons.push(`title matches ICP keyword "${hit}"`);
+      reasons.push(`title matches ICP keyword "${exact}"`);
+    } else if (functional) {
+      score += 0.45;
+      reasons.push(`title matches ICP function "${functional}"`);
     }
   }
   if (levels.length) {
     weightSum += 0.25;
-    const level = (prospect.jobLevel ?? "").toLowerCase();
+    const level = (prospect.jobLevel ?? inferredLevel(title)).toLowerCase();
     if (level && levels.some((l) => level.includes(l))) {
       score += 0.25;
-      reasons.push(`seniority "${prospect.jobLevel}" in ICP levels`);
+      reasons.push(`seniority "${level}" in ICP levels${prospect.jobLevel ? "" : " (inferred from title)"}`);
     }
   }
   if (depts.length) {
     weightSum += 0.15;
-    const dept = (prospect.jobDepartment ?? "").toLowerCase();
+    const dept = (prospect.jobDepartment ?? inferredDepartment(title)).toLowerCase();
     if (dept && depts.some((d) => dept.includes(d))) {
       score += 0.15;
-      reasons.push(`department "${prospect.jobDepartment}" in ICP`);
+      reasons.push(`department "${dept}" in ICP${prospect.jobDepartment ? "" : " (inferred from title)"}`);
     }
   }
   const normalized = weightSum > 0 ? score / weightSum : 0;