@1dolinski/fastforms 0.2.0 → 0.4.0

package/README.md

@@ -1,6 +1,6 @@
 # fastforms
 
-Fill any form fast. Manage multiple personas locally, pick the right one at fill time.
+Fill any form fast. Manage multiple personas locally, pick the right ones at fill time.
 
 ## Quick start
 
@@ -8,9 +8,8 @@ Fill any form fast. Manage multiple personas locally, pick the right one at fill
 # 1. Create your first user + business persona
 npx @1dolinski/fastforms init
 
-# 2. Add more personas
-npx @1dolinski/fastforms add user
-npx @1dolinski/fastforms add business
+# 2. Add a form persona (org context + form-specific answers)
+npx @1dolinski/fastforms add form
 
 # 3. Enable remote debugging in Chrome
 #    Open chrome://inspect/#remote-debugging and toggle it on
@@ -22,15 +21,27 @@ npx @1dolinski/fastforms fill https://example.com/apply
 ## How it works
 
 1. **`fastforms init`** walks you through creating user + business personas interactively
-2. Personas are saved as individual JSON files in `.fastforms/users/` and `.fastforms/businesses/`
-3. **`fastforms fill <url>`** connects to Chrome, lets you pick personas, fills by label matching
-4. **Review and submit manually** in Chrome
+2. **`fastforms add form`** captures the form's org, purpose, and form-specific answers
+3. Personas are saved as individual JSON files in `.fastforms/`
+4. **`fastforms fill <url>`** connects to Chrome, picks personas, fills by label matching
+5. Form personas auto-match by URL — no need to specify which one
+6. **Review and submit manually** in Chrome
 
 ## Requirements
 
 - Chrome >= 144
 - Node.js >= 18
 
+## Persona types
+
+| Type | What it captures | Example |
+|---|---|---|
+| **User** | Who you are | Name, email, role, GitHub, bio |
+| **Business** | What you're building | Company, product, traction, one-liner |
+| **Form** | Who's asking & why | Org, purpose, form-specific answers |
+
+Form persona facts **override** user/business data. "What attracts you to Nitro" belongs on the Nitro form persona, not on your user persona.
+
 ## Commands
 
 | Command | Description |
@@ -38,6 +49,7 @@ npx @1dolinski/fastforms fill https://example.com/apply
 | `fastforms init` | Create your first user + business persona |
 | `fastforms add user` | Add another user persona |
 | `fastforms add business` | Add another business persona |
+| `fastforms add form` | Add a form persona (org + answers) |
 | `fastforms list` | Show all saved personas |
 | `fastforms fill <url>` | Fill any form (pick from personas) |
 | `fastforms edit` | Edit an existing persona |
@@ -50,6 +62,7 @@ npx @1dolinski/fastforms fill https://example.com/apply
 |---|---|
 | `--user <hint>` | Pre-select user persona by name |
 | `--business <hint>` | Pre-select business persona by name |
+| `--form <hint>` | Pre-select form persona by name |
 | `--web` | Use web app personas instead of local files |
 | `--dir <path>` | Custom persona directory path |
 | `--port <port>` | Chrome debug port (auto-detected) |
@@ -59,15 +72,18 @@ npx @1dolinski/fastforms fill https://example.com/apply
 ```
 .fastforms/
   users/
-    chris.json          # A user persona
-    work-chris.json     # Another user persona
+    chris.json
+    work-chris.json
   businesses/
-    apinow.json         # A business persona
-    sideproject.json    # Another business persona
-  defaults.json         # Remembers your last selection
+    apinow.json
+    sideproject.json
+  forms/
+    nitro-accelerator.json
+    yc-application.json
+  defaults.json
 ```
 
-Each user JSON file — just fill in what you have:
+### User persona (`users/chris.json`)
 
 ```json
 {
@@ -86,7 +102,7 @@ Each user JSON file — just fill in what you have:
 }
 ```
 
-Each business JSON file:
+### Business persona (`businesses/apinow.json`)
 
 ```json
 {
@@ -98,6 +114,27 @@ Each business JSON file:
 }
 ```
 
+### Form persona (`forms/nitro-accelerator.json`)
+
+```json
+{
+  "name": "Nitro Accelerator",
+  "urls": ["nitroacc.xyz"],
+  "organization": "Nitro",
+  "purpose": "Crypto accelerator application for early-stage founders",
+  "notes": "NYC-based, 1-month residency",
+  "deadline": "2026-04-01",
+  "facts": {
+    "attracts": "The density of high-signal founders and the NYC residency",
+    "mentor": "Vitalik — his work on public goods aligns with our mission",
+    "spend": "Engineering hires and infrastructure for mainnet launch",
+    "last week": "Shipped v2 of the API, onboarded 3 beta customers"
+  }
+}
+```
+
+The `facts` on a form persona are form-specific answers keyed by label hints. They override user/business data when a form field matches.
+
 ## Web app (optional)
 
 You can also manage personas in the web UI at [293-fastforms.vercel.app/persona](https://293-fastforms.vercel.app/persona) and use `--web` flag to pull from there. The web app has an "Export for CLI" button to download your personas as local JSON files.
@@ -116,7 +153,7 @@ node bin/fastforms.js fill https://example.com/apply
 
 ### Adding a new form mapping
 
-1. Add a `buildXxxData(user, biz)` function in `lib/fill.js`
+1. Add a `buildXxxData(user, biz, form)` function in `lib/fill.js`
 2. Add a URL check in `fillForm()`
 3. Test with `node bin/fastforms.js fill <url>`
 

package/SKILL.md

@@ -11,15 +11,18 @@ Use this skill when the user says any of:
 - "fill this form with my persona"
 - "use fastforms", "fastforms fill"
 - "set up my personas", "init fastforms"
-- "add a persona", "add another persona"
+- "add a persona", "add a form persona"
 
 ## What it does
 
 `fastforms` is a CLI tool that:
 
-1. Manages multiple personas locally in `.fastforms/users/` and `.fastforms/businesses/` directories
+1. Manages three types of personas locally in `.fastforms/`:
+   - **User** — who you are (name, email, bio, skills)
+   - **Business** — what you're building (company, product, traction)
+   - **Form** — who's asking and why (org, purpose, form-specific answers)
 2. Connects to Chrome via the DevTools Protocol
-3. Lets you pick which user + business persona to use at fill time
+3. Lets you pick which user + business + form persona to use at fill time
 4. Fills any form using label-matching — never submits
 
 ## Quick start
@@ -28,9 +31,8 @@ Use this skill when the user says any of:
 # 1. Create your first user + business persona
 npx @1dolinski/fastforms init
 
-# 2. Add more personas
-npx @1dolinski/fastforms add user
-npx @1dolinski/fastforms add business
+# 2. Add a form persona with org context and form-specific answers
+npx @1dolinski/fastforms add form
 
 # 3. Enable remote debugging in Chrome
 #    Open chrome://inspect/#remote-debugging
@@ -43,65 +45,72 @@ npx @1dolinski/fastforms fill https://example.com/apply
 
 ### `npx @1dolinski/fastforms init`
 
-Walks through creating a user + business persona. Saves to `.fastforms/users/<name>.json` and `.fastforms/businesses/<name>.json`.
+Walks through creating a user + business persona (optionally a form persona too).
 
-### `npx @1dolinski/fastforms add user|business`
+### `npx @1dolinski/fastforms add user|business|form`
 
-Add another user or business persona. Run as many times as you want.
+Add another persona of any type.
 
 ### `npx @1dolinski/fastforms list`
 
-Show all saved personas.
+Show all saved personas across all types.
 
 ### `npx @1dolinski/fastforms fill <url>`
 
-Fills any form. If you have multiple personas, prompts you to pick which ones to use.
+Fills any form. If you have multiple personas, prompts you to pick. Form personas auto-match by URL.
 
 Options:
 - `--user <hint>` — pre-select a user persona by name
 - `--business <hint>` — pre-select a business persona by name
+- `--form <hint>` — pre-select a form persona by name
 - `--web` — use web app personas (https://293-fastforms.vercel.app) instead of local files
 - `--dir <path>` — custom path to persona directory
 - `--port <port>` — Chrome debug port (auto-detected by default)
 
 ### `npx @1dolinski/fastforms edit`
 
-Pick a persona to edit interactively.
+Pick any persona to edit interactively.
 
 ### `npx @1dolinski/fastforms remove`
 
-Pick a persona to delete.
+Pick any persona to delete.
 
-### `npx @1dolinski/fastforms personas`
+## Persona types
 
-Opens the web persona manager in Chrome.
+### User persona
+Who you are. Name, email, role, GitHub, LinkedIn, bio, custom facts.
 
-## Persona sources
+### Business persona
+What you're building. Company, product, one-liner, traction, business model.
 
-1. **Local `.fastforms/` directory** (default) — simple JSON files, no web app needed
-2. **Web app** (`--web` flag) — https://293-fastforms.vercel.app/persona manages personas in localStorage, CLI reads via CDP
+### Form persona
+Who's asking and why. The organization that owns the form, the form's purpose, and **form-specific answers** that override user/business data. For example, "what attracts you to Nitro" is a Nitro-specific answer — it belongs on the form persona, not on your user or business persona.
+
+Form personas auto-match by URL. If your form persona has `urls: ["nitroacc.xyz"]` and you fill `https://nitroacc.xyz/apply`, it auto-selects.
 
 ## How it works
 
-1. Reads all personas from `.fastforms/users/` and `.fastforms/businesses/`
+1. Reads all personas from `.fastforms/users/`, `.fastforms/businesses/`, and `.fastforms/forms/`
 2. If multiple, prompts you to pick which user + business persona to use
-3. Auto-discovers Chrome's debug port from `DevToolsActivePort`
-4. Opens (or reuses) the target form URL tab
-5. Fills using label-matching heuristics. Has site-specific mappings for known forms.
-6. Shows what was filled, what was skipped. **Never submits.**
+3. Auto-matches form persona by URL (or prompts if multiple)
+4. Auto-discovers Chrome's debug port from `DevToolsActivePort`
+5. Opens (or reuses) the target form URL tab
+6. Fills using label-matching. Form persona facts are checked first as overrides.
+7. Shows what was filled, what was skipped. **Never submits.**
 
 ## Agent instructions
 
 When the user asks you to fill a form:
 
 1. Check if `.fastforms/` exists. If not, run `npx @1dolinski/fastforms init`
-2. Run `npx @1dolinski/fastforms fill <the-url>`
-3. If Chrome debugging isn't enabled, tell the user to open `chrome://inspect/#remote-debugging`
-4. After filling, tell the user to review in Chrome and submit manually
+2. If the form is new, suggest `npx @1dolinski/fastforms add form` to capture form-specific context
+3. Run `npx @1dolinski/fastforms fill <the-url>`
+4. If Chrome debugging isn't enabled, tell the user to open `chrome://inspect/#remote-debugging`
+5. After filling, tell the user to review in Chrome and submit manually
 
 When the user wants to add a persona:
 
-1. Run `npx @1dolinski/fastforms add user` or `npx @1dolinski/fastforms add business`
+1. Run `npx @1dolinski/fastforms add user|business|form`
 
 When the user wants to see their personas:
 

package/bin/fastforms.js

@@ -10,6 +10,7 @@ import {
   connectToChrome,
   pullPersonas,
   selectPersonas,
+  selectFormPersona,
   showPersonaDetails,
   offerSetDefaults,
   offerOpenPersonaManager,
@@ -21,12 +22,14 @@ import {
   loadLocalPersonas,
   saveUserPersona,
   saveBusinessPersona,
+  saveFormPersona,
   deletePersonaFile,
   listPersonaFiles,
   loadDefaults,
   saveDefaults,
   userTemplate,
   businessTemplate,
+  formTemplate,
 } from "../lib/local.js";
 
 const args = process.argv.slice(2);
@@ -69,6 +72,7 @@ function help() {
     fastforms init                  Create your first user + business persona
     fastforms add user              Add another user persona
     fastforms add business          Add another business persona
+    fastforms add form              Add a form persona (org + purpose + answers)
     fastforms list                  List all personas
     fastforms edit                  Edit an existing persona
     fastforms remove                Remove a persona
@@ -81,11 +85,17 @@ function help() {
     --dir <path>        Path to .fastforms/ directory (default: auto-detect)
     --user <hint>       User persona name/hint to pre-select
     --business <hint>   Business persona name/hint to pre-select
+    --form <hint>       Form persona name/hint to pre-select
     --port <port>       Chrome debug port (auto-detected by default)
 
+  Persona types:
+    user      — who you are (name, email, bio, skills)
+    business  — what you're building (company, product, traction)
+    form      — who's asking and why (org, purpose, form-specific answers)
+
   Quick start:
     1. npx @1dolinski/fastforms init
-    2. npx @1dolinski/fastforms add user          # add more personas
+    2. npx @1dolinski/fastforms add form          # add form-specific context
     3. Enable remote debugging: chrome://inspect/#remote-debugging
     4. npx @1dolinski/fastforms fill https://example.com/apply
 `);
@@ -172,6 +182,55 @@ async function promptBusiness(existing) {
   return b;
 }
 
+async function promptForm(existing) {
+  const ep = existing?.profile || {};
+  const f = formTemplate();
+
+  const show = (val) => val ? ` [${String(val).slice(0, 40)}]` : "";
+
+  f.name = await ask(`  Form name (e.g. "Nitro Accelerator")${show(existing?.name)}: `, existing?.name || "");
+  f.organization = await ask(`  Organization${show(ep.organization)}: `, ep.organization || "");
+  f.purpose = await ask(`  Purpose (e.g. "crypto accelerator application")${show(ep.purpose)}: `, ep.purpose || "");
+
+  const existingUrls = existing?.urls || [];
+  if (existingUrls.length) {
+    console.log(`\n  Current URLs: ${existingUrls.join(", ")}`);
+  }
+  console.log("\n  Add URL patterns this form matches (press Enter to finish):\n");
+  f.urls = [...existingUrls];
+  while (true) {
+    const url = await ask("  url: ");
+    if (!url) break;
+    if (!f.urls.includes(url)) f.urls.push(url);
+  }
+
+  f.notes = await ask(`  Notes / context${show(ep.notes)}: `, ep.notes || "");
+  f.deadline = await ask(`  Deadline${show(ep.deadline)}: `, ep.deadline || "");
+  f.requirements = await ask(`  Requirements${show(ep.requirements)}: `, ep.requirements || "");
+
+  const existingFacts = {};
+  for (const cf of (existing?.customFacts || [])) {
+    if (cf.enabled !== false && cf.key) existingFacts[cf.key] = cf.value;
+  }
+  f.facts = { ...existingFacts };
+
+  if (Object.keys(f.facts).length) {
+    console.log("\n  Current form-specific answers:");
+    for (const [k, v] of Object.entries(f.facts)) console.log(`    ${k} = ${v}`);
+  }
+  console.log("\n  Add form-specific answers (label hint = answer). Press Enter to finish.");
+  console.log("  These override user/business data for matching fields.\n");
+  while (true) {
+    const raw = await ask("  answer: ");
+    if (!raw) break;
+    const eq = raw.indexOf("=");
+    if (eq === -1) { console.log("    Use format: field hint = answer"); continue; }
+    f.facts[raw.slice(0, eq).trim()] = raw.slice(eq + 1).trim();
+  }
+
+  return f;
+}
+
 // ---------------------------------------------------------------------------
 // init — first-time setup: one user + one business
 // ---------------------------------------------------------------------------
@@ -185,7 +244,7 @@ async function init() {
   if (existingUsers.length) {
     const ans = await ask(`  ${existingUsers.length} persona(s) already exist. Add another? [Y/n]: `);
     if (ans.toLowerCase() === "n") {
-      console.log("  Use 'fastforms add user' or 'fastforms add business' to add more.\n");
+      console.log("  Use 'fastforms add user|business|form' to add more.\n");
       closeRL();
       return;
     }
@@ -202,7 +261,16 @@ async function init() {
   const bizSlug = saveBusinessPersona(dir, biz);
   console.log(`\n  Saved businesses/${bizSlug}.json`);
 
+  const addForm = await ask("\n  Add a form persona now? (org + purpose + form-specific answers) [y/N]: ");
+  if (addForm.toLowerCase() === "y") {
+    console.log("\n  --- Form persona ---\n");
+    const form = await promptForm();
+    const formSlug = saveFormPersona(dir, form);
+    console.log(`\n  Saved forms/${formSlug}.json`);
+  }
+
   console.log(`\n  Personas saved to ${dir}/`);
+  console.log("  Tip: add form-specific context with 'fastforms add form'");
   console.log("  Next: npx @1dolinski/fastforms fill <url>\n");
   closeRL();
 }
@@ -213,8 +281,8 @@ async function init() {
 
 async function addPersona() {
   const type = args[1];
-  if (type !== "user" && type !== "business") {
-    console.error("  Usage: fastforms add user|business\n");
+  if (type !== "user" && type !== "business" && type !== "form") {
+    console.error("  Usage: fastforms add user|business|form\n");
     process.exit(1);
   }
 
@@ -226,11 +294,16 @@ async function addPersona() {
     const user = await promptUser();
     const slug = saveUserPersona(dir, user);
     console.log(`\n  Saved users/${slug}.json to ${dir}/\n`);
-  } else {
+  } else if (type === "business") {
     console.log("\n  --- New business persona ---\n");
     const biz = await promptBusiness();
     const slug = saveBusinessPersona(dir, biz);
     console.log(`\n  Saved businesses/${slug}.json to ${dir}/\n`);
+  } else {
+    console.log("\n  --- New form persona ---\n");
+    const form = await promptForm();
+    const slug = saveFormPersona(dir, form);
+    console.log(`\n  Saved forms/${slug}.json to ${dir}/\n`);
   }
   closeRL();
 }
@@ -250,6 +323,7 @@ function listAll() {
 
   const users = listPersonaFiles(dir, "user");
   const businesses = listPersonaFiles(dir, "business");
+  const forms = listPersonaFiles(dir, "form");
 
   console.log(`\n  Personas in ${dir}/\n`);
 
@@ -276,6 +350,20 @@ function listAll() {
   }
 
   console.log();
+
+  if (forms.length) {
+    console.log("  Form personas:");
+    for (const f of forms) {
+      const urls = f.data?.urls?.length ? ` [${f.data.urls.join(", ")}]` : "";
+      const purpose = f.data?.purpose ? ` — ${f.data.purpose}` : "";
+      const facts = f.data?.facts ? Object.keys(f.data.facts).length : 0;
+      console.log(`    ${f.slug}${urls}${purpose}${facts ? ` (${facts} answers)` : ""}`);
+    }
+  } else {
+    console.log("  No form personas. Run: fastforms add form");
+  }
+
+  console.log();
 }
 
 // ---------------------------------------------------------------------------
@@ -291,9 +379,11 @@ async function edit() {
 
   const users = listPersonaFiles(dir, "user");
   const businesses = listPersonaFiles(dir, "business");
+  const forms = listPersonaFiles(dir, "form");
   const all = [
     ...users.map((u) => ({ ...u, type: "user", label: `user: ${u.slug} (${u.data?.fullName || u.data?.name || "?"})` })),
     ...businesses.map((b) => ({ ...b, type: "business", label: `biz: ${b.slug} (${b.data?.name || "?"})` })),
+    ...forms.map((f) => ({ ...f, type: "form", label: `form: ${f.slug} (${f.data?.organization || f.data?.name || "?"})` })),
   ];
 
   if (!all.length) {
@@ -317,13 +407,20 @@ async function edit() {
     if (updated.name !== picked.data?.name) deletePersonaFile(dir, "user", picked.slug);
     const slug = saveUserPersona(dir, updated);
     console.log(`\n  Updated users/${slug}.json\n`);
-  } else {
+  } else if (picked.type === "business") {
     const existing = dump.businessPersonas.find((p) => p.name === picked.data?.name) || null;
     console.log(`\n  --- Edit business: ${picked.slug} ---\n`);
     const updated = await promptBusiness(existing);
     if (updated.name !== picked.data?.name) deletePersonaFile(dir, "business", picked.slug);
     const slug = saveBusinessPersona(dir, updated);
     console.log(`\n  Updated businesses/${slug}.json\n`);
+  } else {
+    const existing = (dump.formPersonas || []).find((p) => p.name === picked.data?.name) || null;
+    console.log(`\n  --- Edit form: ${picked.slug} ---\n`);
+    const updated = await promptForm(existing);
+    if (updated.name !== picked.data?.name) deletePersonaFile(dir, "form", picked.slug);
+    const slug = saveFormPersona(dir, updated);
+    console.log(`\n  Updated forms/${slug}.json\n`);
   }
   closeRL();
 }
@@ -341,9 +438,11 @@ async function remove() {
 
   const users = listPersonaFiles(dir, "user");
   const businesses = listPersonaFiles(dir, "business");
+  const forms = listPersonaFiles(dir, "form");
   const all = [
     ...users.map((u) => ({ ...u, type: "user", label: `user: ${u.slug} (${u.data?.fullName || u.data?.name || "?"})` })),
     ...businesses.map((b) => ({ ...b, type: "business", label: `biz: ${b.slug} (${b.data?.name || "?"})` })),
+    ...forms.map((f) => ({ ...f, type: "form", label: `form: ${f.slug} (${f.data?.name || "?"})` })),
   ];
 
   if (!all.length) {
@@ -361,7 +460,8 @@ async function remove() {
   const confirm = await ask(`  Delete ${picked.type}/${picked.slug}? [y/N]: `);
   if (confirm.toLowerCase() === "y") {
     deletePersonaFile(dir, picked.type, picked.slug);
-    console.log(`  Removed ${picked.type}s/${picked.slug}.json\n`);
+    const dirName = picked.type === "user" ? "users" : picked.type === "business" ? "businesses" : "forms";
+    console.log(`  Removed ${dirName}/${picked.slug}.json\n`);
   } else {
     console.log("  Cancelled.\n");
   }
@@ -408,7 +508,13 @@ async function fill() {
 
   const personas = dump.personas || [];
   const bizPersonas = dump.businessPersonas || [];
-  console.log(`  Found ${personas.length} user persona(s), ${bizPersonas.length} business persona(s).`);
+  const formPersonas = dump.formPersonas || [];
+  const counts = [
+    `${personas.length} user`,
+    `${bizPersonas.length} business`,
+    `${formPersonas.length} form`,
+  ].join(", ");
+  console.log(`  Found ${counts} persona(s).`);
 
   if (!personas.length && !bizPersonas.length) {
     console.error("\n  No personas found.");
@@ -423,15 +529,29 @@ async function fill() {
 
   const userHint = flag("--user");
   const bizHint = flag("--business");
+  const formHint = flag("--form");
   const { user, biz } = await selectPersonas(dump, userHint, bizHint);
 
+  // Form persona: auto-match by URL, then hint, then interactive
+  let form = null;
+  if (formPersonas.length) {
+    if (formHint) {
+      form = formPersonas.find((f) =>
+        f.name.toLowerCase().includes(formHint.toLowerCase())
+      ) || null;
+    }
+    if (!form) {
+      form = await selectFormPersona(formPersonas, formUrl);
+    }
+  }
+
   if (!user && !biz) {
     console.error("\n  No matching personas.");
     browser.disconnect();
     process.exit(1);
   }
 
-  showPersonaDetails(user, biz);
+  showPersonaDetails(user, biz, form);
 
   const pages = await browser.pages();
   const host = new URL(formUrl).host;
@@ -446,15 +566,18 @@ async function fill() {
     console.log(`\n  Opened ${formUrl}`);
   }
 
-  await fillForm(page, formUrl, user, biz);
+  await fillForm(page, formUrl, user, biz, form);
 
   if (hasFlag("--web")) {
     await offerSetDefaults(user, biz);
   } else {
-    // Save defaults to local dir
     const dir = findFastformsDir();
-    if (dir && user && biz) {
-      saveDefaults(dir, { defaultUser: user.name, defaultBusiness: biz.name });
+    if (dir) {
+      const patch = {};
+      if (user) patch.defaultUser = user.name;
+      if (biz) patch.defaultBusiness = biz.name;
+      if (form) patch.defaultForm = form.name;
+      saveDefaults(dir, patch);
     }
   }
 

package/lib/cdp.js

@@ -0,0 +1,193 @@
+import WebSocket from "ws";
+
+const DEFAULT_TIMEOUT = 30_000;
+const SETTLE_MS = 1000;
+
+// ---------------------------------------------------------------------------
+// CDP session — thin wrapper around a single WebSocket to a Chrome target
+// ---------------------------------------------------------------------------
+
+class CDPSession {
+  constructor(ws) {
+    this._ws = ws;
+    this._nextId = 0;
+    this._pending = new Map();
+    this._listeners = new Map();
+
+    ws.on("message", (raw) => {
+      const msg = JSON.parse(raw);
+      if ("id" in msg) {
+        const cb = this._pending.get(msg.id);
+        if (cb) {
+          this._pending.delete(msg.id);
+          msg.error ? cb.reject(new Error(msg.error.message)) : cb.resolve(msg.result);
+        }
+      } else if (msg.method) {
+        const fns = this._listeners.get(msg.method);
+        if (fns) for (const fn of fns) fn(msg.params);
+      }
+    });
+
+    ws.on("close", () => {
+      for (const { reject } of this._pending.values()) reject(new Error("WebSocket closed"));
+      this._pending.clear();
+    });
+  }
+
+  send(method, params = {}) {
+    const id = ++this._nextId;
+    return new Promise((resolve, reject) => {
+      this._pending.set(id, { resolve, reject });
+      this._ws.send(JSON.stringify({ id, method, params }));
+    });
+  }
+
+  on(event, fn) {
+    if (!this._listeners.has(event)) this._listeners.set(event, []);
+    this._listeners.get(event).push(fn);
+  }
+
+  off(event, fn) {
+    const fns = this._listeners.get(event);
+    if (!fns) return;
+    const idx = fns.indexOf(fn);
+    if (idx !== -1) fns.splice(idx, 1);
+  }
+
+  close() {
+    this._ws.close();
+  }
+}
+
+async function openSession(wsUrl) {
+  const ws = new WebSocket(wsUrl);
+  await new Promise((resolve, reject) => {
+    ws.once("open", resolve);
+    ws.once("error", reject);
+  });
+  return new CDPSession(ws);
+}
+
+// ---------------------------------------------------------------------------
+// Page — mirrors the subset of puppeteer's Page API we actually use
+// ---------------------------------------------------------------------------
+
+class Page {
+  constructor(info, port) {
+    this._info = info;
+    this._port = port;
+    this._session = null;
+  }
+
+  url() {
+    return this._info.url;
+  }
+
+  async _ensureSession() {
+    if (!this._session) {
+      this._session = await openSession(this._info.webSocketDebuggerUrl);
+    }
+    return this._session;
+  }
+
+  /**
+   * Evaluate a function in the page context.
+   * Works the same as puppeteer's page.evaluate — pass a function + args,
+   * they get serialized and executed in the browser, result comes back.
+   */
+  async evaluate(fn, ...args) {
+    const session = await this._ensureSession();
+    const expression = `(${fn.toString()})(${args.map((a) => JSON.stringify(a)).join(",")})`;
+    const { result, exceptionDetails } = await session.send("Runtime.evaluate", {
+      expression,
+      returnByValue: true,
+      awaitPromise: true,
+    });
+    if (exceptionDetails) {
+      throw new Error(
+        exceptionDetails.text ||
+        exceptionDetails.exception?.description ||
+        "evaluate failed"
+      );
+    }
+    return result?.value;
+  }
+
+  async goto(url, opts = {}) {
+    const session = await this._ensureSession();
+    await session.send("Page.enable");
+
+    const loaded = new Promise((resolve) => {
+      const timer = setTimeout(resolve, opts.timeout || DEFAULT_TIMEOUT);
+      const handler = () => {
+        clearTimeout(timer);
+        session.off("Page.loadEventFired", handler);
+        setTimeout(resolve, SETTLE_MS);
+      };
+      session.on("Page.loadEventFired", handler);
+    });
+
+    await session.send("Page.navigate", { url });
+    await loaded;
+    this._info.url = url;
+  }
+
+  async bringToFront() {
+    const session = await this._ensureSession();
+    await session.send("Page.bringToFront");
+  }
+
+  async close() {
+    this._dispose();
+    try {
+      await fetch(`http://127.0.0.1:${this._port}/json/close/${this._info.id}`, { method: "PUT" });
+    } catch { /* best effort */ }
+  }
+
+  _dispose() {
+    if (this._session) {
+      this._session.close();
+      this._session = null;
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// connectChrome — returns a browser-like object
+// ---------------------------------------------------------------------------
+
+export async function connectChrome(port = 9222) {
+  const base = `http://127.0.0.1:${port}`;
+
+  const res = await fetch(`${base}/json/version`);
+  if (!res.ok) throw new Error(`Chrome not responding on port ${port}`);
+
+  const sessions = [];
+
+  return {
+    async pages() {
+      const res = await fetch(`${base}/json/list`);
+      const targets = await res.json();
+      return targets
+        .filter((t) => t.type === "page")
+        .map((t) => {
+          const p = new Page(t, port);
+          sessions.push(p);
+          return p;
+        });
+    },
+
+    async newPage() {
+      const res = await fetch(`${base}/json/new`, { method: "PUT" });
+      const target = await res.json();
+      const p = new Page(target, port);
+      sessions.push(p);
+      return p;
+    },
+
+    disconnect() {
+      for (const p of sessions) p._dispose();
+      sessions.length = 0;
+    },
+  };
+}

package/lib/fill.js

@@ -2,6 +2,14 @@ import { getCustomFact } from "./personas.js";
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
+/**
+ * Look up a value from the form persona's facts first, then fall back.
+ * Form persona facts override everything — they're form-specific answers.
+ */
+function formFact(form, key) {
+  return getCustomFact(form, key);
+}
+
 export async function fillByLabel(page, label, value, opts = {}) {
   if (!value) return false;
   return page.evaluate((lbl, val, ta) => {
@@ -55,82 +63,95 @@ export async function clickCheckbox(page, textHint) {
   }, textHint);
 }
 
-export function buildNitroData(user, biz) {
+export function buildNitroData(user, biz, form) {
   const u = user?.profile || {};
   const b = biz?.profile || {};
   const fact = (p, k) => getCustomFact(p, k);
+  const ff = (k) => formFact(form, k);
 
   return {
     fields: [
-      { label: "Company / Project name", value: b.productName || b.companyName || b.name || "" },
-      { label: "Email", value: u.email || "" },
-      { label: "One-line description", value: b.oneLiner || "" },
-      { label: "What are you building", value: b.solution || [b.problem, b.solution].filter(Boolean).join("\n\n"), textarea: true },
-      { label: "Full Name", value: u.fullName || "" },
-      { label: "Role in the company", value: u.currentRole || "" },
-      { label: "X Handle", value: fact(user, "x handle") || fact(user, "twitter") || "" },
-      { label: "LinkedIn username", value: u.linkedIn || "" },
-      { label: "Telegram", value: fact(user, "telegram") || "" },
-      { label: "GitHub username", value: u.github || "" },
-      { label: "Why are you the right founder", value: [u.bio, u.keySkills ? `Key skills: ${u.keySkills}` : "", u.favoriteProjects ? `Notable projects: ${u.favoriteProjects}` : ""].filter(Boolean).join("\n\n"), textarea: true },
-      { label: "video content or long form writing", value: u.portfolio || "", textarea: true },
-      { label: "How did the founders meet", value: fact(user, "founders met") || fact(biz, "founders") || `I'm a solo founder building ${b.productName || b.companyName || "this project"} full-time.`, textarea: true },
-      { label: "Current location of founders", value: u.location || b.location || "" },
-      { label: "how do you plan to spend", value: fact(biz, "spend") || fact(biz, "500k") || "", textarea: true },
-      { label: "What problem are you solving", value: b.problem || "", textarea: true },
-      { label: "closest comparables", value: b.differentiators || "", textarea: true },
-      { label: "Product Link", value: b.website || "" },
-      { label: "What changed in the tech or market", value: fact(biz, "timing") || fact(biz, "why now") || b.rawFacts || "", textarea: true },
-      { label: "Dune Dashboard", value: "" },
-      { label: "Google Analytics", value: "", textarea: true },
-      { label: "target segment", value: b.targetUsers || "", textarea: true },
-      { label: "wedge into the market", value: b.businessModel || b.differentiators || "", textarea: true },
-      { label: "traction have you achieved", value: b.traction || "", textarea: true },
-      { label: "Runway at current burn", value: "12" },
-      { label: "What attracts you the most about Nitro", value: fact(biz, "nitro") || fact(biz, "accelerator") || `The density of high-signal founders and the NYC residency. ${b.productName || "Our product"} is at a stage where concentrated feedback from experienced operators would dramatically accelerate our trajectory.`, textarea: true },
-      { label: "Pick one of the mentors", value: fact(biz, "mentor") || "", textarea: true },
-      { label: "What did you get done last week", value: fact(biz, "last week") || fact(user, "last week") || "", textarea: true },
+      { label: "Company / Project name", value: ff("company") || b.productName || b.companyName || b.name || "" },
+      { label: "Email", value: ff("email") || u.email || "" },
+      { label: "One-line description", value: ff("one-line") || b.oneLiner || "" },
+      { label: "What are you building", value: ff("building") || b.solution || [b.problem, b.solution].filter(Boolean).join("\n\n"), textarea: true },
+      { label: "Full Name", value: ff("full name") || u.fullName || "" },
+      { label: "Role in the company", value: ff("role") || u.currentRole || "" },
+      { label: "X Handle", value: ff("x handle") || fact(user, "x handle") || fact(user, "twitter") || "" },
+      { label: "LinkedIn username", value: ff("linkedin") || u.linkedIn || "" },
+      { label: "Telegram", value: ff("telegram") || fact(user, "telegram") || "" },
+      { label: "GitHub username", value: ff("github") || u.github || "" },
+      { label: "Why are you the right founder", value: ff("right founder") || [u.bio, u.keySkills ? `Key skills: ${u.keySkills}` : "", u.favoriteProjects ? `Notable projects: ${u.favoriteProjects}` : ""].filter(Boolean).join("\n\n"), textarea: true },
+      { label: "video content or long form writing", value: ff("video") || ff("writing") || u.portfolio || "", textarea: true },
+      { label: "How did the founders meet", value: ff("founders meet") || ff("founders met") || fact(user, "founders met") || fact(biz, "founders") || `I'm a solo founder building ${b.productName || b.companyName || "this project"} full-time.`, textarea: true },
+      { label: "Current location of founders", value: ff("location") || u.location || b.location || "" },
+      { label: "how do you plan to spend", value: ff("spend") || ff("500k") || fact(biz, "spend") || fact(biz, "500k") || "", textarea: true },
+      { label: "What problem are you solving", value: ff("problem") || b.problem || "", textarea: true },
+      { label: "closest comparables", value: ff("comparables") || ff("competitors") || b.differentiators || "", textarea: true },
+      { label: "Product Link", value: ff("product link") || b.website || "" },
+      { label: "What changed in the tech or market", value: ff("timing") || ff("why now") || fact(biz, "timing") || fact(biz, "why now") || b.rawFacts || "", textarea: true },
+      { label: "Dune Dashboard", value: ff("dune") || "" },
+      { label: "Google Analytics", value: ff("analytics") || "", textarea: true },
+      { label: "target segment", value: ff("target") || b.targetUsers || "", textarea: true },
+      { label: "wedge into the market", value: ff("wedge") || ff("market") || b.businessModel || b.differentiators || "", textarea: true },
+      { label: "traction have you achieved", value: ff("traction") || b.traction || "", textarea: true },
+      { label: "Runway at current burn", value: ff("runway") || "12" },
+      { label: "What attracts you the most about Nitro", value: ff("attracts") || ff("nitro") || fact(biz, "nitro") || fact(biz, "accelerator") || `The density of high-signal founders and the NYC residency. ${b.productName || "Our product"} is at a stage where concentrated feedback from experienced operators would dramatically accelerate our trajectory.`, textarea: true },
+      { label: "Pick one of the mentors", value: ff("mentor") || fact(biz, "mentor") || "", textarea: true },
+      { label: "What did you get done last week", value: ff("last week") || fact(biz, "last week") || fact(user, "last week") || "", textarea: true },
     ],
     radios: [
-      { section: "committed full-time", value: "yes" },
-      { section: "raised funding before", value: "no" },
-      { section: "currently fundraising", value: "yes" },
-      { section: "exclusively in Nitro", value: "yes" },
-      { section: "attend the full 1-month NYC", value: "yes" },
+      { section: "committed full-time", value: ff("full-time") || "yes" },
+      { section: "raised funding before", value: ff("raised funding") || "no" },
+      { section: "currently fundraising", value: ff("fundraising") || "yes" },
+      { section: "exclusively in Nitro", value: ff("exclusively") || "yes" },
+      { section: "attend the full 1-month NYC", value: ff("attend") || "yes" },
     ],
     checkboxes: ["MVP / demo exists"],
   };
 }
 
-export async function genericFill(page, user, biz) {
+export async function genericFill(page, user, biz, form) {
   const u = user?.profile || {};
   const b = biz?.profile || {};
   const fact = (p, k) => getCustomFact(p, k);
+  const ff = (k) => formFact(form, k);
 
   const fieldMap = [
-    { hints: ["company", "project name", "organization"], value: b.productName || b.companyName || b.name || "" },
-    { hints: ["email"], value: u.email || "" },
-    { hints: ["full name", "your name", "first name"], value: u.fullName || "" },
-    { hints: ["one-line", "one liner", "tagline", "short description"], value: b.oneLiner || "" },
-    { hints: ["what are you building", "describe your product", "about your project"], value: b.solution || "", textarea: true },
-    { hints: ["role", "title", "position"], value: u.currentRole || "" },
-    { hints: ["x handle", "twitter"], value: fact(user, "x handle") || fact(user, "twitter") || "" },
-    { hints: ["linkedin"], value: u.linkedIn || "" },
-    { hints: ["telegram"], value: fact(user, "telegram") || "" },
-    { hints: ["github"], value: u.github || "" },
-    { hints: ["website", "url", "product link"], value: b.website || u.portfolio || "" },
-    { hints: ["phone", "tel"], value: u.phone || "" },
-    { hints: ["location", "city", "where are you based"], value: u.location || b.location || "" },
-    { hints: ["bio", "about yourself", "tell us about you"], value: u.bio || "", textarea: true },
-    { hints: ["problem", "what problem"], value: b.problem || "", textarea: true },
-    { hints: ["solution", "how does it work"], value: b.solution || "", textarea: true },
-    { hints: ["traction", "progress", "metrics"], value: b.traction || "", textarea: true },
-    { hints: ["target", "customer", "user"], value: b.targetUsers || "", textarea: true },
-    { hints: ["business model", "revenue", "monetiz"], value: b.businessModel || "", textarea: true },
-    { hints: ["differentiator", "competitive", "unique"], value: b.differentiators || "", textarea: true },
-    { hints: ["why you", "right founder", "why are you"], value: u.bio || "", textarea: true },
+    { hints: ["company", "project name", "organization"], value: ff("company") || b.productName || b.companyName || b.name || "" },
+    { hints: ["email"], value: ff("email") || u.email || "" },
+    { hints: ["full name", "your name", "first name"], value: ff("full name") || u.fullName || "" },
+    { hints: ["one-line", "one liner", "tagline", "short description"], value: ff("one-liner") || b.oneLiner || "" },
+    { hints: ["what are you building", "describe your product", "about your project"], value: ff("building") || b.solution || "", textarea: true },
+    { hints: ["role", "title", "position"], value: ff("role") || u.currentRole || "" },
+    { hints: ["x handle", "twitter"], value: ff("x handle") || fact(user, "x handle") || fact(user, "twitter") || "" },
+    { hints: ["linkedin"], value: ff("linkedin") || u.linkedIn || "" },
+    { hints: ["telegram"], value: ff("telegram") || fact(user, "telegram") || "" },
+    { hints: ["github"], value: ff("github") || u.github || "" },
+    { hints: ["website", "url", "product link"], value: ff("website") || b.website || u.portfolio || "" },
+    { hints: ["phone", "tel"], value: ff("phone") || u.phone || "" },
+    { hints: ["location", "city", "where are you based"], value: ff("location") || u.location || b.location || "" },
+    { hints: ["bio", "about yourself", "tell us about you"], value: ff("bio") || u.bio || "", textarea: true },
+    { hints: ["problem", "what problem"], value: ff("problem") || b.problem || "", textarea: true },
+    { hints: ["solution", "how does it work"], value: ff("solution") || b.solution || "", textarea: true },
+    { hints: ["traction", "progress", "metrics"], value: ff("traction") || b.traction || "", textarea: true },
+    { hints: ["target", "customer", "user"], value: ff("target") || b.targetUsers || "", textarea: true },
+    { hints: ["business model", "revenue", "monetiz"], value: ff("business model") || b.businessModel || "", textarea: true },
+    { hints: ["differentiator", "competitive", "unique"], value: ff("differentiator") || b.differentiators || "", textarea: true },
+    { hints: ["why you", "right founder", "why are you"], value: ff("right founder") || u.bio || "", textarea: true },
   ];
 
+  // Append any form persona facts that don't already map to standard fields
+  if (form?.customFacts?.length) {
+    const usedKeys = new Set(fieldMap.flatMap((f) => f.hints));
+    for (const cf of form.customFacts) {
+      if (!cf.enabled || !cf.value) continue;
+      const keyLower = cf.key.toLowerCase();
+      if ([...usedKeys].some((h) => keyLower.includes(h) || h.includes(keyLower))) continue;
+      fieldMap.push({ hints: [cf.key], value: cf.value, textarea: cf.value.length > 100 });
+    }
+  }
+
   let filled = 0, skipped = 0;
   for (const f of fieldMap) {
     if (!f.value) { skipped++; continue; }
@@ -146,12 +167,16 @@ export async function genericFill(page, user, biz) {
   return { filled, skipped };
 }
 
-export async function fillForm(page, formUrl, user, biz) {
+export async function fillForm(page, formUrl, user, biz, form) {
   console.log(`\n  Filling form...\n`);
+  if (form) {
+    const fp = form.profile || {};
+    if (fp.organization) console.log(`  Form: ${fp.organization}${fp.purpose ? ` — ${fp.purpose}` : ""}`);
+  }
   await sleep(2000);
 
   if (formUrl.includes("nitroacc.xyz")) {
-    const data = buildNitroData(user, biz);
+    const data = buildNitroData(user, biz, form);
     let filled = 0, skipped = 0;
 
     for (const f of data.fields) {
@@ -180,7 +205,7 @@ export async function fillForm(page, formUrl, user, biz) {
 
     console.log(`\n  Filled ${filled}, skipped ${skipped} (empty persona fields).`);
   } else {
-    const { filled, skipped } = await genericFill(page, user, biz);
+    const { filled, skipped } = await genericFill(page, user, biz, form);
     console.log(`\n  Filled ${filled}, skipped ${skipped} (empty or no match).`);
   }
 

package/lib/local.js

@@ -87,6 +87,23 @@ function normalizeBusiness(raw) {
   };
 }
 
+function normalizeForm(raw) {
+  if (!raw) return null;
+  const { name, facts, urls, ...rest } = raw;
+  return {
+    name: name || "unknown form",
+    urls: urls || (rest.url ? [rest.url] : []),
+    profile: {
+      organization: rest.organization || rest.org || name || "",
+      purpose: rest.purpose || "",
+      notes: rest.notes || "",
+      deadline: rest.deadline || "",
+      requirements: rest.requirements || "",
+    },
+    customFacts: factsToArray(facts),
+  };
+}
+
 function factsToArray(facts) {
   if (!facts || typeof facts !== "object") return [];
   return Object.entries(facts).map(([key, value], i) => ({
@@ -125,7 +142,9 @@ export function loadLocalPersonas(dir) {
     if (legacy) businessPersonas = [normalizeBusiness(legacy)];
   }
 
-  return { personas, businessPersonas };
+  const formPersonas = loadDir(join(dir, "forms"), normalizeForm);
+
+  return { personas, businessPersonas, formPersonas };
 }
 
 // ---------------------------------------------------------------------------
@@ -146,8 +165,17 @@ export function saveBusinessPersona(dir, data) {
   return slug;
 }
 
+export function saveFormPersona(dir, data) {
+  const subdir = ensureDir(join(dir, "forms"));
+  const slug = slugify(data.name || "form");
+  writeJson(join(subdir, `${slug}.json`), data);
+  return slug;
+}
+
+const TYPE_DIRS = { user: "users", business: "businesses", form: "forms" };
+
 export function deletePersonaFile(dir, type, slug) {
-  const subdir = type === "user" ? "users" : "businesses";
+  const subdir = TYPE_DIRS[type] || type;
   const path = join(dir, subdir, `${slug}.json`);
   if (existsSync(path)) unlinkSync(path);
 }
@@ -157,7 +185,7 @@ export function deletePersonaFile(dir, type, slug) {
 // ---------------------------------------------------------------------------
 
 export function listPersonaFiles(dir, type) {
-  const subdir = join(dir, type === "user" ? "users" : "businesses");
+  const subdir = join(dir, TYPE_DIRS[type] || type);
   if (!existsSync(subdir)) return [];
   return readdirSync(subdir)
     .filter((f) => f.endsWith(".json"))
@@ -215,3 +243,16 @@ export function businessTemplate() {
     facts: {},
   };
 }
+
+export function formTemplate() {
+  return {
+    name: "",
+    urls: [],
+    organization: "",
+    purpose: "",
+    notes: "",
+    deadline: "",
+    requirements: "",
+    facts: {},
+  };
+}

package/lib/personas.js

@@ -1,8 +1,8 @@
-import puppeteer from "puppeteer-core";
-import { readFileSync, writeFileSync, existsSync } from "fs";
+import { readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 import { createInterface } from "readline";
+import { connectChrome } from "./cdp.js";
 
 const FASTFORMS_URL = "https://293-fastforms.vercel.app/";
 const PERSONA_URL = "https://293-fastforms.vercel.app/persona";
@@ -28,7 +28,7 @@ function ask(prompt) {
 }
 
 export async function connectToChrome(port = 9222) {
-  return puppeteer.connect({ browserURL: `http://127.0.0.1:${port}` });
+  return connectChrome(port);
 }
 
 export async function pullPersonas(browser) {
@@ -92,7 +92,7 @@ function printPersonaSummary(label, persona, profileKeys) {
   if (facts.length) console.log(`    Custom facts: ${facts.length}`);
 }
 
-export function showPersonaDetails(user, biz) {
+export function showPersonaDetails(user, biz, form) {
   printPersonaSummary("User persona", user, [
     ["fullName", "Name"],
     ["email", "Email"],
@@ -108,29 +108,36 @@ export function showPersonaDetails(user, biz) {
     ["website", "Website"],
     ["category", "Category"],
   ]);
+  if (form) {
+    console.log(`\n  Form persona: ${form.name}`);
+    const fp = form.profile || {};
+    if (fp.organization) console.log(`    Organization: ${fp.organization}`);
+    if (fp.purpose) console.log(`    Purpose: ${fp.purpose}`);
+    if (fp.deadline) console.log(`    Deadline: ${fp.deadline}`);
+    if (fp.notes) console.log(`    Notes: ${String(fp.notes).slice(0, 80)}${String(fp.notes).length > 80 ? "..." : ""}`);
+    const facts = (form.customFacts || []).filter((f) => f.enabled !== false && f.value);
+    if (facts.length) console.log(`    Form-specific answers: ${facts.length}`);
+  }
 }
 
 // ---------------------------------------------------------------------------
-// Interactive persona selection — supports multiple personas from any source
+// Interactive persona selection
 // ---------------------------------------------------------------------------
 
 async function pickFromList(label, list, hint, keys, defaultName) {
   if (!list?.length) return null;
   if (list.length === 1) return list[0];
 
-  // Try hint-based match
   if (hint) {
     const match = pickPersona(list, hint, keys);
     if (match) return match;
   }
 
-  // Try default
   if (defaultName) {
     const match = list.find((p) => p.name === defaultName);
     if (match) return match;
   }
 
-  // Interactive selection
   console.log(`\n  ${label}:\n`);
   list.forEach((p, i) => {
     const detail = keys.map((k) => k.split(".").reduce((o, s) => o?.[s], p)).filter(Boolean)[0] || "";
@@ -142,6 +149,42 @@ async function pickFromList(label, list, hint, keys, defaultName) {
   return list[0];
 }
 
+export function matchFormByUrl(formPersonas, targetUrl) {
+  if (!formPersonas?.length || !targetUrl) return null;
+  const lower = targetUrl.toLowerCase();
+  for (const fp of formPersonas) {
+    for (const u of (fp.urls || [])) {
+      if (u && lower.includes(u.toLowerCase())) return fp;
+    }
+    const orgSlug = (fp.name || "").toLowerCase().replace(/[^a-z0-9]/g, "");
+    if (orgSlug && lower.includes(orgSlug)) return fp;
+  }
+  return null;
+}
+
+export async function selectFormPersona(formPersonas, targetUrl) {
+  if (!formPersonas?.length) return null;
+
+  const autoMatch = matchFormByUrl(formPersonas, targetUrl);
+  if (autoMatch) {
+    console.log(`  Auto-matched form persona: ${autoMatch.name}`);
+    return autoMatch;
+  }
+
+  if (formPersonas.length === 1) return formPersonas[0];
+
+  console.log(`\n  Form personas:\n`);
+  formPersonas.forEach((f, i) => {
+    const org = f.profile?.organization || "";
+    console.log(`    ${i + 1}. ${f.name}${org ? ` (${org})` : ""}`);
+  });
+  console.log(`    ${formPersonas.length + 1}. (none — skip form persona)`);
+  const ans = await ask(`\n  Pick form persona [1-${formPersonas.length + 1}]: `);
+  const idx = Number(ans) - 1;
+  if (idx >= 0 && idx < formPersonas.length) return formPersonas[idx];
+  return null;
+}
+
 export async function selectPersonas(dump, userHint, bizHint) {
   const config = loadConfig();
   const personas = dump.personas || [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1dolinski/fastforms",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Fill any form fast. Manage personas on the web, fill forms from your terminal.",
   "type": "module",
   "bin": {
@@ -13,7 +13,7 @@
     "README.md"
   ],
   "dependencies": {
-    "puppeteer-core": "^24.39.1"
+    "ws": "^8.18.0"
   },
   "engines": {
     "node": ">=18"
@@ -27,7 +27,7 @@
     "forms",
     "automation",
     "chrome",
-    "puppeteer",
+    "cdp",
     "personas"
   ]
 }