fullstackgtm 0.45.0 → 0.47.0

package/src/cli/help.ts

@@ -9,11 +9,15 @@ export function usage() {
 and apply only explicitly approved operations.
 
 Usage:
-  fullstackgtm login --via <hosted url>        pair with a team deployment (recommended)
-  fullstackgtm login hubspot [--no-validate]
-  fullstackgtm login hubspot --oauth --client-id <id> [--port ${DEFAULT_LOOPBACK_PORT}] [--scopes a,b]
-  fullstackgtm login salesforce --device --client-id <consumer key> [--login-url <url>]
-  fullstackgtm login salesforce --instance-url <url> [--no-validate]
+  fullstackgtm login hubspot                  hosted browser OAuth (default; no app needed)
+  fullstackgtm login salesforce               hosted browser OAuth (default; no app needed)
+  fullstackgtm login hubspot --hosted [--via <url>]
+  fullstackgtm login salesforce --hosted [--via <url>]
+  fullstackgtm login --via <hosted url>        pair with a team deployment (broker only)
+  fullstackgtm login hubspot --private-token [--no-validate]      advanced: paste private app token
+  fullstackgtm login hubspot --oauth --client-id <id> [--port ${DEFAULT_LOOPBACK_PORT}] [--scopes a,b]  advanced: BYO HubSpot app
+  fullstackgtm login salesforce --device --client-id <consumer key> [--login-url <url>]  advanced: BYO Connected App
+  fullstackgtm login salesforce --instance-url <url> [--no-validate]  advanced: paste access token
   fullstackgtm login stripe [--no-validate]
   fullstackgtm login anthropic | openai        store an LLM API key for call parse/score
   fullstackgtm login apollo                    store an Apollo API key for enrich pulls\n  fullstackgtm login pipe0 | explorium | theirstack  store a discovery-provider key (theirstack = technographic TAM)\n  fullstackgtm login heyreach                  store a HeyReach key for enrich acquire --source linkedin\n  fullstackgtm logout <hubspot|salesforce|stripe|anthropic|openai|apollo|pipe0|explorium|heyreach|broker>
@@ -21,7 +25,7 @@ Usage:
   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
   interactive prompt:
-    echo "$HUBSPOT_TOKEN" | fullstackgtm login hubspot
+    echo "$HUBSPOT_TOKEN" | fullstackgtm login hubspot --private-token
   fullstackgtm init [--source pipe0|explorium|linkedin] [--provider hubspot|salesforce] [--out <dir>] [--force]
                                                cold start: scaffold icp.json + enrich.config.json + a
                                                PLAYBOOK wired for this workspace (the CLI ships primitives,
@@ -31,16 +35,18 @@ Usage:
   fullstackgtm report [source options] [audit options] [report options]
   fullstackgtm diff --before <a.json> --after <b.json> [--json] [--fail-on-new-findings]
   fullstackgtm merge --input <a.json> --input <b.json> [...] --out <merged.json> [--json]
-  fullstackgtm call parse --transcript <file> [--title t] [--source fathom|granola|...] [--model m] [--deterministic] [--json|--ndjson] [--out <path>]
+  fullstackgtm call parse --transcript <file> [--title t] [--source fathom|granola|...] [--model m] [--llm] [--heuristics] [--json|--ndjson] [--out <path>]
   fullstackgtm call classify --transcript <file>|--call <parsed.json> [--llm] [--deterministic] [--json]
   fullstackgtm call score --transcript <file>|--call <parsed.json> [--call-type <t>] [--rubric <rubric.json>] [--model m] [--json|--out <path>]
   fullstackgtm call link --attendees <a@x.com,...> | --domain <x.com>  [source options] [--json]
   fullstackgtm call plan --transcript <file>|--call <parsed.json> --deal <id> [source options] [--save|--json]
-                                               calls become evidence: LLM extraction by default (bring your own
-                                               Anthropic or OpenAI key — captured once on first use, or
-                                               ANTHROPIC_API_KEY/OPENAI_API_KEY, or \`login anthropic|openai\`);
-                                               --deterministic uses the free keyword baseline. Then link the call
-                                               to its deal and propose governed next-step writes.
+                                               calls become evidence: chunked LLM extraction by default when a
+                                               key resolves (ANTHROPIC_API_KEY/OPENAI_API_KEY or \`login
+                                               anthropic|openai\`), free deterministic fallback when none does;
+                                               --heuristics (alias --deterministic) forces the deterministic
+                                               engine, --llm forces the LLM path. Model: --model, else env
+                                               FSGTM_INSIGHTS_MODEL. Then link the call to its deal and propose
+                                               governed next-step writes.
   fullstackgtm resolve <account|contact|deal> [--name N] [--domain D] [--email E] [--account-id A] [source options] [--json]
                                                the create gate: exit 0 = safe to create, exit 2 = match
                                                found (exists/ambiguous) — call before ANY record creation
@@ -80,6 +86,15 @@ Usage:
                                                fill-blanks-only patch plan through the normal dry-run →
                                                approve → apply gate. refresh re-checks stale stamped fields
                                                and proposes updates only where the source value changed.
+  fullstackgtm backfill stripe|runs [--since <iso>] [--pipeline <id|label>] [--match-property <name>] [--skip-unmatched] [source options] [--save] [--dry-run] [--json]
+                                               revenue truth backfill: one closed-won deal per PAID Stripe
+                                               invoice (amount = invoice total, close date = paid date,
+                                               associated to the matched customer account, deduped by
+                                               invoice id). Reads Stripe + the CRM snapshot, emits a
+                                               dry-run create_record plan through the normal approve →
+                                               apply gate; unmatched customers get a proposed NEW account
+                                               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 list [--since 7d] [--bucket b] [--account d] [--unjudged]
   fullstackgtm signals outcome --account <d> [--touch <id>] --result replied|meeting|bounced|no_reply
@@ -188,13 +203,14 @@ Authentication (checked in order):
   1. --token-env <name>        explicit env var for this invocation (hubspot)
   2. ambient env               HUBSPOT_ACCESS_TOKEN, or SALESFORCE_ACCESS_TOKEN +
                                SALESFORCE_INSTANCE_URL (CI, agent sandboxes)
-  3. stored provider login     fullstackgtm login <provider>; kept in ~/.fullstackgtm
-                               (hubspot: private app token or loopback OAuth;
-                               salesforce: device flow — code on any device, no
-                               secret, silent refresh)
-  4. broker pairing            fullstackgtm login --via <url>: the team connects the
-                               CRM once in the hosted dashboard; every paired CLI
-                               uses those stored sync credentials from then on
+  3. stored provider login     BYO direct credentials kept in ~/.fullstackgtm
+                               (hubspot: --private-token or loopback OAuth;
+                               salesforce: pasted token or device flow). These
+                               direct credentials override broker-hosted tokens.
+  4. hosted/broker login        fullstackgtm login hubspot|salesforce (or --hosted):
+                               hosted browser OAuth stores a broker credential;
+                               provider tokens are minted server-side. \`login --via
+                               <url>\` pairs with an existing team deployment broker.
 
 Source options (snapshot and audit):
   --sample               Built-in minimal mock CRM data (default)
@@ -280,12 +296,13 @@ export const HELP: Record<string, HelpEntry> = {
     summary: "connect a provider or LLM key (secrets via stdin/env, never argv)",
     phase: "Setup",
     synopsis: [
+      "fullstackgtm login hubspot | salesforce          hosted browser OAuth (default)",
       "fullstackgtm login --via <hosted url>            pair with a team deployment",
-      "fullstackgtm login hubspot | salesforce | stripe",
+      "fullstackgtm login stripe",
       "fullstackgtm login anthropic | openai | apollo",
     ],
     detail:
-      "Secrets are NEVER passed as flags (they leak via the process list and shell history) — pipe on stdin or enter at the prompt: `echo \"$TOKEN\" | fullstackgtm login hubspot`.",
+      "HubSpot/Salesforce use hosted browser OAuth by default; BYO app/token paths are advanced. Secrets are NEVER passed as flags — pipe on stdin or enter at the prompt: `echo \"$TOKEN\" | fullstackgtm login hubspot --private-token`.",
     seeAlso: ["doctor", "logout", "profiles"],
   },
   logout: {
@@ -442,6 +459,27 @@ export const HELP: Record<string, HelpEntry> = {
       "Extra `--where` scoping is account-lifted for deals/contacts. `--except-deal-stage <stage>` excludes that stage and any record whose account has an open deal in it, re-verified per record at apply.",
     seeAlso: ["bulk-update", "plans", "apply"],
   },
+  backfill: {
+    summary: "Stripe paid invoices → closed-won deal proposals (governed)",
+    phase: "Remediate",
+    synopsis: [
+      "fullstackgtm backfill stripe|runs [--since <iso>] [--pipeline <id|label>] [--match-property <name>] [--skip-unmatched] [source options] [--save] [--dry-run] [--json]",
+    ],
+    detail:
+      "`backfill runs` replays LOCAL execution history to the paired hosted app (idempotent: deterministic run ids + server-side dedupe): every stored plan's apply runs and the health.jsonl timeline, so the hosted feed and Home health trend cover the engagement from its CLI-only beginning. Requires `login --via`; only what live reporting sends leaves the machine (statuses, counts, timestamps, scores — never CRM field values). `backfill stripe`: billing is the revenue source of truth — proposes ONE closed-won deal per paid Stripe invoice (amount = invoice total, close date = paid date, associated to the matched customer account, deduped by invoice id). Customers are matched to CRM accounts by domain, then exact name; a customer the CRM doesn't know gets an explicit proposed ACCOUNT create in the same plan (billing-email domain used unless it is freemail; a customer with no usable name/domain stays report-only; `--skip-unmatched` restores report-only for all unmatched). Emits a dry-run create_record plan — nothing is written until `plans approve` → `apply`, where the connector re-resolves each invoice id (and each account by domain/name) and creates only on a confirmed miss. Deal creation is HubSpot-only for now.",
+    options: [
+      ["--since <iso>", "only invoices created on/after this timestamp"],
+      ["--pipeline <id|label>", "target deal pipeline (default: the portal's default pipeline)"],
+      ["--match-property <name>", "deal dedupe property stamped with the invoice id (default stripe_invoice_id)"],
+      ["--skip-unmatched", "do not propose accounts for unmatched customers (report-only, the pre-1.3 behavior)"],
+      ["--provider <name>", "CRM snapshot to match against: hubspot | salesforce"],
+      ["--input <path>", "match against a saved snapshot JSON instead of a live pull"],
+      ["--save", "persist the dry-run plan for approve → apply"],
+      ["--json", "machine-readable {plan, counts, unmatched, proposedAccounts} (stripe) or replay summary (runs)"],
+      ["--dry-run", "(runs) count what would be replayed without sending anything"],
+    ],
+    seeAlso: ["enrich", "plans", "apply", "resolve"],
+  },
   enrich: {
     summary: "governed third-party enrichment (Apollo/Clay), fill-blanks-only",
     phase: "Remediate",
@@ -457,7 +495,7 @@ export const HELP: Record<string, HelpEntry> = {
     phase: "Remediate",
     synopsis: ["fullstackgtm call parse|classify|score|link|plan …  (run `call --help` for full options)"],
     detail:
-      "`parse` normalizes any transcript into canonical segments + evidence (LLM by default, bring your own key; `--deterministic` for the free baseline). `classify` picks the call type, `score` rates it against the type's rubric, `link` finds the deal, `plan` proposes governed next-step writes.",
+      "`parse` normalizes any transcript into canonical segments + evidence — chunked LLM extraction by default when a key resolves (ANTHROPIC_API_KEY/OPENAI_API_KEY or `login anthropic|openai`), free deterministic fallback when none does; `--heuristics` forces the deterministic engine, `--llm` forces the LLM path, model via `--model` or env FSGTM_INSIGHTS_MODEL. `classify` picks the call type, `score` rates it against the type's rubric, `link` finds the deal, `plan` proposes governed next-step writes.",
     seeAlso: ["plans", "apply"],
   },
 
@@ -585,7 +623,7 @@ export function shortUsage() {
     ["Setup & health", ["login", "logout", "doctor", "capabilities", "robot-docs", "profiles", "health"]],
     ["Detect — read-only", ["audit", "report", "snapshot", "diff", "rules"]],
     ["Prevent — gate writes", ["resolve"]],
-    ["Remediate — governed writes", ["fix", "bulk-update", "dedupe", "reassign", "enrich"]],
+    ["Remediate — governed writes", ["fix", "bulk-update", "dedupe", "reassign", "enrich", "backfill"]],
     ["Calls → evidence", ["call"]],
     ["Govern — the plan/apply spine", ["suggest", "plans", "apply", "audit-log", "merge"]],
     ["Market intelligence", ["market", "tam"]],

package/src/cli/plans.ts

@@ -14,11 +14,12 @@ import { buildAuditLog, verifyAuditLog } from "../auditLog.ts";
 import { createFilePlanStore } from "../planStore.ts";
 import { ENRICH_CONFIG_FILE_NAME, loadEnrichConfig, type EnrichConfig } from "../enrich.ts";
 import { loadMeter, recordConsumption, remaining } from "../acquireMeter.ts";
-import { reportCounts } from "../runReport.ts";
+import { progressReporter, reportCounts } from "../runReport.ts";
+import { APPLY_STAGES, composeListeners, createProgressEmitter } from "../progress.ts";
 import type { ValueSuggestion } from "../suggest.ts";
 import type { CanonicalGtmSnapshot, CreateRecordPayload, PatchOperation, PatchPlan, PatchPlanRun } from "../types.ts";
 import { connectorFor, isOptionValue, numericOption, option, repeatedOption, selectedRules } from "./shared.ts";
-import { colorEnabled, createStatusLine, paint, planStatusWord, stylizePlanMarkdown, table, truncateToWidth } from "./ui.ts";
+import { colorEnabled, createProgressRenderer, paint, planStatusWord, stylizePlanMarkdown, table, truncateToWidth } from "./ui.ts";
 import { unknownSubcommandError } from "./suggest.ts";
 
 
@@ -233,23 +234,23 @@ export async function apply(args: string[]) {
   // A channel (e.g. outbox) renders approved ops to a local artifact and
   // transmits nothing; a CRM provider writes records. Same governed apply path.
   const connector = channel ? createChannelConnector(channel) : await connectorFor(provider!, args);
-  // Interactive terminals get a live safety ticker on stderr while the run
-  // executes; the summary line it leaves behind is plain text. Inert otherwise.
-  const ticker = createStatusLine();
+  // Interactive terminals get a live apply board on stderr while the run
+  // executes (preflight → operations → results, with a per-op safety ticker);
+  // piped runs render nothing. Either way the emitter streams heartbeats to
+  // the paired hosted app when a long run is in flight.
+  const renderer = createProgressRenderer(APPLY_STAGES);
+  const progress = createProgressEmitter(
+    composeListeners(renderer.listener, progressReporter()),
+  );
   let run: PatchPlanRun;
   try {
     run = await applyPatchPlan(connector, plan, {
       approvedOperationIds,
       valueOverrides,
-      onOperation: ticker.active
-        ? (progress) =>
-            ticker.set(
-              `Applying ${progress.completed}/${progress.total} · ✓ ${progress.applied} applied · ${progress.failed} failed · ${progress.conflicts} conflict${progress.conflicts === 1 ? "" : "s"} · ${progress.skipped} skipped`,
-            )
-        : undefined,
+      progress,
     });
   } finally {
-    ticker.done();
+    renderer.done();
   }
   if (planId && store) {
     await store.recordRun(planId, run);
@@ -272,9 +273,9 @@ export async function apply(args: string[]) {
   for (const result of run.results) applyTally[result.status] = (applyTally[result.status] ?? 0) + 1;
   reportCounts(applyTally);
 
-  // Rich-only closing line on stderr (ticker.active implies an interactive,
+  // Rich-only closing line on stderr (renderer.active implies an interactive,
   // color-safe stderr): the one-glance outcome of the run.
-  if (ticker.active) {
+  if (renderer.active) {
     const pe = paint(true);
     const badge =
       run.status === "applied"

package/src/cli/shared.ts

@@ -2,19 +2,22 @@
 
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { createHubspotConnector } from "../connectors/hubspot.ts";
-import { createSalesforceConnector } from "../connectors/salesforce.ts";
-import { createStripeConnector } from "../connectors/stripe.ts";
 import { credentialsPath, getCredential, resolveHubspotConnection, resolveSalesforceConnection, storeCredential } from "../credentials.ts";
-import { generateDemoSnapshot } from "../demo.ts";
 import { builtinAuditRules } from "../rules.ts";
-import { sampleSnapshot } from "../sampleData.ts";
 import { detectProviderFromKey, resolveLlmCredential, validateLlmKey, type LlmProvider } from "../llm.ts";
 import { parseIcp, type Icp } from "../icp.ts";
 import { nearest } from "./suggest.ts";
 import type { FieldMappings } from "../mappings.ts";
-import type { CanonicalGtmSnapshot, GtmConnector, SnapshotProgress } from "../types.ts";
-import { createStatusLine, formatCount, formatDuration } from "./ui.ts";
+import type { CanonicalGtmSnapshot, GtmConnector } from "../types.ts";
+import {
+  composeListeners,
+  createProgressEmitter,
+  SNAPSHOT_PULL_STAGES,
+  STRIPE_SNAPSHOT_STAGES,
+  type ProgressEmitter,
+} from "../progress.ts";
+import { progressReporter } from "../runReport.ts";
+import { createProgressRenderer } from "./ui.ts";
 
 
 export function option(args: string[], name: string) {
@@ -112,27 +115,32 @@ async function salesforceConnection() {
 export async function connectorFor(
   provider: string,
   args: string[],
-  onProgress?: (progress: SnapshotProgress) => void,
+  progress?: ProgressEmitter,
 ): Promise<GtmConnector> {
+  // Connector modules are the two largest files in dist (~100KB together) and
+  // load lazily here: only live `--provider` runs pay for them, not --demo/
+  // --sample/--input runs or the always-eager help/version paths.
   if (provider === "hubspot") {
     const connection = await hubspotConnection(args);
+    const { createHubspotConnector } = await import("../connectors/hubspot.ts");
     return createHubspotConnector({
       getAccessToken: () => connection.accessToken,
       fieldMappings: (connection.fieldMappings as FieldMappings | undefined) ?? undefined,
       // Point at a mock/proxy HubSpot (tests, evals, request-recording).
       apiBaseUrl: process.env.HUBSPOT_API_BASE_URL,
-      onProgress,
+      progress,
     });
   }
   if (provider === "salesforce") {
     const connection = await salesforceConnection();
+    const { createSalesforceConnector } = await import("../connectors/salesforce.ts");
     return createSalesforceConnector({
       getConnection: () => connection,
       fieldMappings:
         ((connection as { fieldMappings?: unknown }).fieldMappings as
           | FieldMappings
           | undefined) ?? undefined,
-      onProgress,
+      progress,
     });
   }
   if (provider === "stripe") {
@@ -143,7 +151,8 @@ export async function connectorFor(
         "No Stripe credentials. Run `echo \"$STRIPE_KEY\" | fullstackgtm login stripe` or set STRIPE_SECRET_KEY. A restricted key with read access to Customers and Subscriptions is enough. (`fullstackgtm doctor` shows credential status.)",
       );
     }
-    return createStripeConnector({ getApiKey: () => key });
+    const { createStripeConnector } = await import("../connectors/stripe.ts");
+    return createStripeConnector({ getApiKey: () => key, progress });
   }
   const providerSuggestion = nearest(provider.toLowerCase(), ["hubspot", "salesforce", "stripe"], 3);
   throw new Error(
@@ -152,37 +161,45 @@ export async function connectorFor(
   );
 }
 
-export async function readSnapshot(args: string[]): Promise<CanonicalGtmSnapshot> {
+export async function readSnapshot(
+  args: string[],
+  progress?: ProgressEmitter,
+): Promise<CanonicalGtmSnapshot> {
   const provider = option(args, "--provider");
   if (provider) {
+    // A verb driving its own progress board (e.g. `backfill stripe`) passes
+    // its emitter through; the pull's stage/items events flow into it and no
+    // second board is painted.
+    if (progress) {
+      const connector = await connectorFor(provider, args, progress);
+      return connector.fetchSnapshot();
+    }
     // Live pulls can page for minutes with nothing on screen. On an
-    // interactive terminal, a stderr status line shows the running tally;
-    // piped/CI/agent runs get an inert no-op (zero bytes written).
-    const status = createStatusLine();
-    const startedAt = Date.now();
-    const connector = await connectorFor(
-      provider,
-      args,
-      status.active
-        ? (progress) =>
-            status.set(
-              `Pulling ${progress.objectType}s from ${provider}… ${formatCount(progress.fetched)} fetched · ${formatDuration(Date.now() - startedAt)}`,
-            )
-        : undefined,
+    // interactive terminal, a stderr checklist ticks through the pull stages
+    // with running tallies; piped/CI/agent runs render nothing (zero bytes
+    // written). Either way the emitter feeds the broker heartbeat when the
+    // CLI is paired, so long pulls tick live on the hosted dashboard too.
+    const renderer = createProgressRenderer(
+      provider === "stripe" ? STRIPE_SNAPSHOT_STAGES : SNAPSHOT_PULL_STAGES,
+    );
+    const emitter = createProgressEmitter(
+      composeListeners(renderer.listener, progressReporter()),
     );
+    const connector = await connectorFor(provider, args, emitter);
     try {
       return await connector.fetchSnapshot();
     } finally {
-      status.done();
+      renderer.done();
     }
   }
   if (args.includes("--demo")) {
+    const { generateDemoSnapshot } = await import("../demo.ts");
     return generateDemoSnapshot({
       seed: numericOption(args, "--seed"),
       today: option(args, "--today") ?? undefined,
     });
   }
-  if (args.includes("--sample")) return sampleSnapshot;
+  if (args.includes("--sample")) return (await import("../sampleData.ts")).sampleSnapshot;
   const input = option(args, "--input");
   if (!input) {
     throw new Error(

package/src/cli/ui.ts

@@ -11,6 +11,8 @@
 //   - NO_COLOR (https://no-color.org), TERM=dumb, and CI disable styling;
 //     FORCE_COLOR (non-"0") re-enables it, matching the wider ecosystem.
 
+import type { ProgressEvent, ProgressListener, ProgressSnapshot } from "../progress.ts";
+
 type StreamLike = {
   isTTY?: boolean;
   columns?: number;
@@ -358,6 +360,76 @@ export function createChecklist(
   };
 }
 
+export type ProgressRenderer = {
+  /**
+   * Feed to `createProgressEmitter` (compose with the broker streaming
+   * listener via `composeListeners` when the run should also heartbeat).
+   */
+  listener: ProgressListener;
+  /** Stop animating and erase the board (callers print their own summary). */
+  done(): void;
+  readonly active: boolean;
+};
+
+const NOOP_RENDERER: ProgressRenderer = { listener: () => {}, done() {}, active: false };
+
+/**
+ * Adapter from the shared progress vocabulary (src/progress.ts) to the
+ * existing TTY primitives: `stage` events advance a live checklist (○ → ⠹ →
+ * ✓), while `items` / `note` / `opResult` / `meter` events annotate the
+ * running stage ("contacts 1,200/4,800", the apply ticker tallies, a fuel
+ * gauge). Outside an interactive TTY this is an inert no-op — piped/CI/agent
+ * output stays byte-identical (streaming listeners composed alongside still
+ * run; rendering is presentation only).
+ */
+export function createProgressRenderer(
+  stages: readonly string[],
+  stream: StreamLike = process.stderr,
+  env: UiEnv = process.env,
+): ProgressRenderer {
+  const board = createChecklist(
+    stages.map((stage) => ({ id: stage, label: stage })),
+    stream,
+    env,
+  );
+  if (!board.active) return NOOP_RENDERER;
+  let current: string | null = null;
+  const noteFor = (event: ProgressEvent, snapshot: ProgressSnapshot): string | undefined => {
+    if (event.kind === "items") {
+      return event.total !== undefined
+        ? `${formatCount(event.done)}/${formatCount(event.total)}`
+        : formatCount(event.done);
+    }
+    if (event.kind === "note") return event.note;
+    if (event.kind === "opResult") {
+      return `${GLYPH.ok} ${formatCount(snapshot.opsApplied)} applied · ${formatCount(snapshot.opsFailed)} failed · ${formatCount(snapshot.opsSkipped)} skipped`;
+    }
+    if (event.kind === "meter") {
+      const fraction = event.budget > 0 ? event.spent / event.budget : 0;
+      return `${formatBar(fraction, 10)} ${formatCount(event.spent)}/${formatCount(event.budget)} ${event.unit}`;
+    }
+    return undefined;
+  };
+  return {
+    listener(event, snapshot) {
+      if (event.kind === "stage") {
+        // Advance the board: close out the previous stage, spin the new one.
+        if (current && current !== event.stage) board.update(current, "ok");
+        current = event.stage;
+        board.update(current, "running");
+        return;
+      }
+      // Events for a stage the board doesn't know (e.g. a nested pull inside a
+      // larger flow) are ignored by createChecklist's unknown-id no-op.
+      if (current) board.update(current, "running", noteFor(event, snapshot));
+    },
+    done() {
+      board.done();
+    },
+    active: true,
+  };
+}
+
 /** Truncate to `max` display characters, ending in "…" when cut. */
 export function truncateToWidth(text: string, max: number): string {
   if (max <= 0) return "";
@@ -421,6 +493,5 @@ export function stylizePlanMarkdown(text: string, p: Paint): string {
 
 /** Strip ANSI escape sequences (test helper + safety net for width math). */
 export function stripAnsi(text: string): string {
-  // eslint-disable-next-line no-control-regex
   return text.replace(/\u001b\[[0-9;]*[A-Za-z]/g, "");
 }

package/src/cli.ts

@@ -1,22 +1,15 @@
 import { activeProfile, listProfiles, setActiveProfile } from "./credentials.ts";
-import { audit, healthCommand, reportCommand, rulesCommand, snapshotCommand } from "./cli/audit.ts";
-import { doctorCommand, login, logout } from "./cli/auth.ts";
 import { capabilitiesCommand, printCommandHelpJson, robotDocsCommand, unknownCommandEnvelope } from "./cli/capabilities.ts";
-import { callCommand } from "./cli/call.ts";
-import { draftCommand } from "./cli/draft.ts";
-import { enrichCommand } from "./cli/enrich.ts";
-import { bulkUpdateCommand, dedupeCommand, fixCommand, reassignCommand, resolveCommand, suggest } from "./cli/fix.ts";
 import { BESPOKE_HELP, commandHelp, HELP, shortUsage, stylizeShortUsage, usage } from "./cli/help.ts";
-import { icpCommand } from "./cli/icp.ts";
-import { initCommand } from "./cli/init.ts";
-import { marketCommand } from "./cli/market.ts";
-import { apply, auditLogCommand, diffCommand, mergeCommand, plansCommand } from "./cli/plans.ts";
-import { scheduleCommand } from "./cli/schedule.ts";
 import { readPackageInfo } from "./cli/shared.ts";
 import { correctedCommand, detectFlagTypo, suggestCommand, unknownFlagEnvelope } from "./cli/suggest.ts";
 import { colorEnabled, paint } from "./cli/ui.ts";
-import { signalsCommand } from "./cli/signals.ts";
-import { tamCommand } from "./cli/tam.ts";
+
+// Verb modules load lazily inside their dispatch branch below. The dispatcher
+// used to import all of them eagerly, so `--version` compiled the full
+// 78-module graph (audit, market, enrich, signals, schedule, …) before
+// printing one line. Each branch now `await import()`s only its own module;
+// help/typo/error paths and the exports above stay eager and byte-identical.
 
 
 /**
@@ -129,95 +122,99 @@ export async function runCli(argv: string[]) {
     return;
   }
   if (command === "login") {
-    await login(args);
+    await (await import("./cli/auth.ts")).login(args);
     return;
   }
   if (command === "logout") {
-    logout(args);
+    (await import("./cli/auth.ts")).logout(args);
     return;
   }
   if (command === "snapshot") {
-    await snapshotCommand(args);
+    await (await import("./cli/audit.ts")).snapshotCommand(args);
     return;
   }
   if (command === "audit") {
-    await audit(args);
+    await (await import("./cli/audit.ts")).audit(args);
     return;
   }
   if (command === "report") {
-    await reportCommand(args);
+    await (await import("./cli/audit.ts")).reportCommand(args);
     return;
   }
   if (command === "rules") {
-    await rulesCommand(args);
+    await (await import("./cli/audit.ts")).rulesCommand(args);
     return;
   }
   if (command === "doctor") {
-    await doctorCommand(args);
+    await (await import("./cli/auth.ts")).doctorCommand(args);
     return;
   }
   if (command === "health") {
-    healthCommand(args);
+    (await import("./cli/audit.ts")).healthCommand(args);
     return;
   }
   if (command === "suggest") {
-    await suggest(args);
+    await (await import("./cli/fix.ts")).suggest(args);
     return;
   }
   if (command === "call") {
-    await callCommand(args);
+    await (await import("./cli/call.ts")).callCommand(args);
     return;
   }
   if (command === "resolve") {
-    await resolveCommand(args);
+    await (await import("./cli/fix.ts")).resolveCommand(args);
     return;
   }
   if (command === "bulk-update") {
-    await bulkUpdateCommand(args);
+    await (await import("./cli/fix.ts")).bulkUpdateCommand(args);
     return;
   }
   if (command === "dedupe") {
-    await dedupeCommand(args);
+    await (await import("./cli/fix.ts")).dedupeCommand(args);
     return;
   }
   if (command === "reassign") {
-    await reassignCommand(args);
+    await (await import("./cli/fix.ts")).reassignCommand(args);
     return;
   }
   if (command === "fix") {
-    await fixCommand(args);
+    await (await import("./cli/fix.ts")).fixCommand(args);
     return;
   }
   if (command === "market") {
-    await marketCommand(args);
+    await (await import("./cli/market.ts")).marketCommand(args);
     return;
   }
   if (command === "enrich") {
-    await enrichCommand(args);
+    await (await import("./cli/enrich.ts")).enrichCommand(args);
+    return;
+  }
+  if (command === "backfill") {
+    await (await import("./cli/backfill.ts")).backfillCommand(args);
     return;
   }
   if (command === "init") {
-    initCommand(args);
+    (await import("./cli/init.ts")).initCommand(args);
     return;
   }
   if (command === "tam") {
-    await tamCommand(args);
+    await (await import("./cli/tam.ts")).tamCommand(args);
     return;
   }
   if (command === "icp") {
-    await icpCommand(args);
+    await (await import("./cli/icp.ts")).icpCommand(args);
     return;
   }
   if (command === "signals") {
-    await signalsCommand(args);
+    await (await import("./cli/signals.ts")).signalsCommand(args);
     return;
   }
   if (command === "draft") {
-    await draftCommand(args);
+    await (await import("./cli/draft.ts")).draftCommand(args);
     return;
   }
   if (command === "schedule") {
-    await scheduleCommand(args);
+    await (await import("./cli/schedule.ts")).scheduleCommand(args);
     return;
   }
   if (command === "profiles") {
@@ -225,23 +222,23 @@ export async function runCli(argv: string[]) {
     return;
   }
   if (command === "diff") {
-    await diffCommand(args);
+    await (await import("./cli/plans.ts")).diffCommand(args);
     return;
   }
   if (command === "merge") {
-    await mergeCommand(args);
+    await (await import("./cli/plans.ts")).mergeCommand(args);
     return;
   }
   if (command === "plans") {
-    await plansCommand(args);
+    await (await import("./cli/plans.ts")).plansCommand(args);
     return;
   }
   if (command === "audit-log") {
-    await auditLogCommand(args);
+    await (await import("./cli/plans.ts")).auditLogCommand(args);
     return;
   }
   if (command === "apply") {
-    await apply(args);
+    await (await import("./cli/plans.ts")).apply(args);
     return;
   }