feat(self-driving): fix the onboarding papercuts a customer run surfaced (#1057)

Author: Twixes

package.json

@@ -43,6 +43,7 @@
     "axios": "1.7.4",
     "fast-glob": "^3.3.3",
     "fflate": "^0.8.3",
+    "fuse.js": "^7.5.0",
     "glob": "9.3.5",
     "ink": "^6.8.0",
     "inquirer": "^6.2.0",

pnpm-lock.yaml

@@ -1,3 +1,4 @@
+import { NO_DEFAULT_LIMIT, PRICING_LONG } from './pricing.js';
 /**
  * Self-driving learn-deck — the narrative script played while the agent
  * sets up Self-driving. Teaches the vocabulary ladder (signal source →
@@ -175,9 +176,15 @@ export const getContentBlocks = (store?: WizardStore): ContentBlock[] => {
     },
 
     {
-      content:
-        'That PR is the only thing you pay for: a flat $15 per report that ships a PR. Watching is free.',
-      pause: 6000,
+      // No lead-in: PRICING_LONG already names the PR as what's charged, and the
+      // pane only fits ~148 chars per beat.
+      content: PRICING_LONG,
+      pause: 5000,
+    },
+
+    {
+      content: NO_DEFAULT_LIMIT,
+      pause: 5000,
     },
 
     CLEAR,

src/lib/programs/self-driving/content/index.tsx

@@ -0,0 +1,30 @@
+/**
+ * Self-driving pricing, in one place. It's stated at six points across the run (intro, tips,
+ * learn deck, outro), and a price quoted six ways is a price the reader stops trusting.
+ *
+ * Careful with the word "free". The tracking this wizard installs bills as ordinary PostHog
+ * usage, and scouts are heading for usage-based pricing too — so anything called free here is
+ * a promise with an expiry date. State what the PR costs and leave the rest to usage-based
+ * billing, which stays true either side of that change.
+ */
+
+/** Flat USD charge per report that ships a pull request. */
+export const PRICE_PER_PR_USD = 15;
+
+/** One line, for a screen that only has room to say what it costs. */
+export const PRICING_SHORT = `Agents charge a flat $${PRICE_PER_PR_USD} per pull request they ship.`;
+
+/** The same fact at length, plus the bit people are surprised by later. */
+export const PRICING_LONG =
+  `A report that ships a pull request costs a flat $${PRICE_PER_PR_USD}. ` +
+  `Everything else follows your usual PostHog usage-based pricing.`;
+
+/**
+ * Nothing caps the spend unless you set it, which is worth saying out loud. Checked against
+ * billing: `custom_limits_map` starts empty and a product with no custom limit resolves to
+ * `usage_limit: None`, i.e. uncapped. A free plan is capped by its own allocation instead,
+ * hence the qualifier.
+ */
+export const NO_DEFAULT_LIMIT =
+  'A paid plan has no monthly cap until you set one. Add a PR limit in your inbox sidebar, ' +
+  'and agents pause when they hit it.';

src/lib/programs/self-driving/content/pricing.ts

@@ -1,3 +1,5 @@
+import { NO_DEFAULT_LIMIT, PRICING_LONG } from './pricing.js';
+
 /**
  * Sidebar tips for the self-driving run — short footnotes on the
  * vocabulary ladder (signal source → scout → signal → report → measured
@@ -44,8 +46,7 @@ export const SELF_DRIVING_TIPS: Tip[] = [
   {
     id: 'pricing',
     title: 'What it costs',
-    description:
-      'Watching is free. You pay a flat $15 only when a report ships a PR.',
+    description: `${PRICING_LONG} ${NO_DEFAULT_LIMIT}`,
   },
   {
     id: 'work-anywhere',

src/lib/programs/self-driving/content/tips.ts

@@ -10,6 +10,11 @@ import {
   getSelfDrivingDetectedTools,
 } from './detect.js';
 import { buildSelfDrivingPrompt } from './prompt.js';
+import {
+  NO_DEFAULT_LIMIT,
+  PRICE_PER_PR_USD,
+  PRICING_LONG,
+} from './content/pricing.js';
 import { getTips } from './content/tips.js';
 import { getContentBlocks } from './content/index.js';
 
@@ -90,13 +95,12 @@ const buildRun = (session: WizardSession): Promise<ProgramRun> =>
           items: [
             'Investigate reports with the agent',
             'Tag teammates to loop them in',
-            'Kick off a PR when you like the proposed fix ($15 flat)',
+            `Kick off a PR when you like the proposed fix ($${PRICE_PER_PR_USD} flat)`,
+            'Cap the spend with a monthly PR limit in the sidebar',
             'Or work from Slack (tag @PostHog) and MCP',
           ],
         },
-        body:
-          'Pricing: scouts, signals, and reports are free. You pay a flat ' +
-          '$15 only when a report ships a PR.',
+        body: `${PRICING_LONG} ${NO_DEFAULT_LIMIT}`,
         reportFile: REPORT_FILE,
       };
     },

src/lib/programs/self-driving/index.ts

@@ -184,6 +184,16 @@ STEP 6 — Configure the scout troop. (skill: "Scouts")
    whole troop, including step 6b's custom scouts, stays at or under
    ten enabled scouts.
 
+   Then tell the user what the troop is, before STEP 6b asks them to add
+   to it. Scouts are PostHog's built-in ones, and the user has not seen
+   the list: without it, STEP 6b asks them to approve additions to a
+   baseline they cannot picture. Send one short message naming each
+   scout you enabled with a plain one-line description of what it
+   watches, and say how many you left disabled and that they can turn
+   those on later from the inbox. No wizard_ask here, it is not a
+   question. Keep each line to one sentence and do not restate the
+   skill's internals.
+
 STEP 6b — Design custom scouts for this product. (skill: "Custom scouts")
    You are the only actor that has read this repo — turn that into
    coverage per the skill: a real gap analysis of the project's

src/lib/programs/self-driving/prompt.ts

@@ -0,0 +1,62 @@
+import {
+  buildPickerIndex,
+  rankOptions,
+  type Searchable,
+} from '@ui/tui/primitives/picker-filter';
+
+const OPTIONS: Searchable[] = [
+  { label: 'GitHub issues', hint: 'Issues opened on your repos' },
+  { label: 'GitHub discussions', hint: 'Q&A threads' },
+  { label: 'Error tracking', hint: 'Exceptions captured by PostHog' },
+  { label: 'Session replay', hint: 'Recorded sessions' },
+  { label: 'Linear issues', hint: 'Tickets from Linear' },
+  { label: 'Stripe', hint: 'Payments and subscriptions' },
+  { label: 'Zendesk tickets', hint: 'Support conversations' },
+  { label: 'Snowflake', description: 'Warehouse source' },
+];
+
+function rank(query: string): string[] | null {
+  const ranked = rankOptions(buildPickerIndex(OPTIONS), OPTIONS, query);
+  return ranked?.map((option) => option.label) ?? null;
+}
+
+describe('rankOptions', () => {
+  it('returns null for an empty or whitespace-only query, meaning "unfiltered"', () => {
+    expect(rank('')).toBeNull();
+    expect(rank('   ')).toBeNull();
+  });
+
+  it('ANDs terms, so a query spanning label words narrows to one option', () => {
+    expect(rank('git iss')).toEqual(['GitHub issues']);
+  });
+
+  it('matches case-insensitively', () => {
+    expect(rank('GITHUB')).toEqual(['GitHub issues', 'GitHub discussions']);
+  });
+
+  it('searches hint and description, not just the label', () => {
+    expect(rank('exceptions')).toEqual(['Error tracking']);
+    expect(rank('warehouse')).toEqual(['Snowflake']);
+  });
+
+  it('keeps the list order for literal matches rather than reordering by score', () => {
+    expect(rank('issues')).toEqual(['GitHub issues', 'Linear issues']);
+  });
+
+  it('falls back to fuzzy matching when nothing matches literally', () => {
+    // Dropped vowels: no substring match anywhere, so Fuse takes over and the
+    // intended option has to come back first.
+    expect(rank('gthb')?.[0]).toBe('GitHub discussions');
+    expect(rank('zndsk')?.[0]).toBe('Zendesk tickets');
+  });
+
+  it('does not use the fuzzy pass when a literal match exists', () => {
+    // "replay" fuzzy-matches half the list at this threshold; the literal pass
+    // must win outright so the common case stays tight.
+    expect(rank('replay')).toEqual(['Session replay']);
+  });
+
+  it('returns an empty list when even the fuzzy pass finds nothing', () => {
+    expect(rank('qqqqqq')).toEqual([]);
+  });
+});

src/ui/tui/__tests__/picker-filter.test.ts

@@ -18,6 +18,13 @@ export enum KeyMatch {
   Return = 'return',
   Escape = 'escape',
   Space = 'space',
+  Backspace = 'backspace',
+  /**
+   * Any single printable character typed without a modifier. Broad by design,
+   * so a binding using it must sit last — the first match wins, which is what
+   * lets a specific char binding still take precedence over free typing.
+   */
+  Printable = 'printable',
 }
 
 /** A key match: either a KeyMatch enum value or a literal character string (e.g. 'a', 's'). */
@@ -30,6 +37,8 @@ const DEFAULT_PRIORITY: Record<string, number> = {
   [KeyMatch.LeftArrow]: 1,
   [KeyMatch.RightArrow]: 1,
   [KeyMatch.Space]: 10,
+  [KeyMatch.Printable]: 12,
+  [KeyMatch.Backspace]: 13,
   [KeyMatch.Escape]: 20,
   [KeyMatch.Return]: 21,
 };
@@ -63,6 +72,19 @@ export function matchesKey(
       return !!key.escape;
     case KeyMatch.Space:
       return input === ' ';
+    case KeyMatch.Backspace:
+      return !!key.backspace || !!key.delete;
+    case KeyMatch.Printable:
+      // Ink sets a flag for every non-text key while still passing a non-empty
+      // `input`, so any flag but shift rules out typing.
+      // Any single non-control character, not just ASCII — a filter query can
+      // hold an accented or non-Latin letter.
+      return (
+        input.length === 1 &&
+        input >= ' ' &&
+        input !== '\x7f' &&
+        Object.entries(key).every(([flag, on]) => !on || flag === 'shift')
+      );
     default:
       return input === m;
   }