form-tester 0.9.1 → 0.10.0

package/.claude/skills/form-tester/INSTRUCTIONS.md

@@ -52,113 +52,123 @@ Notes:
 - The CLI opens the form with Playwright CLI, saves an initial snapshot + screenshot, and prints next-step commands.
 - Use `/save {label}` to capture additional snapshots + screenshots into the same output folder.
 - Use `/update` after changing the skill to update Playwright CLI + skills, then reload the skill in Copilot CLI with `/skills` (reload) or `/restart`.
-- Use `/people` to rescan the visible person list and get a numbered selection prompt.
-- Use the next-step checklist printed by the CLI (cookies, person selection, validation fix, Dokumenter verification, save HTML/PDF).
-- If the error modal appears on save or submit ("Det skjedde en feil under innsending av skjema. Prøv igjen senere."), open DevTools -> Network before retrying. Then try resubmitting once. If it persists, find the failed request and capture the Correlation ID header in test_results.txt.
 - Use `--help` or `-h` to print the command list without starting the prompt.
 - IMPORTANT: Always use `form-tester exec` instead of `playwright-cli` directly. This records all commands for replay. Same syntax: `form-tester exec fill e1 "value"`, `form-tester exec click e3`, `form-tester exec close` (finalizes recording).
 - Replay a previous run: `form-tester replay output/form-id/timestamp/recording.json`
 - IMPORTANT: When something unexpected happens during a test — wrong page state, unexpected modal, failed command, element not found, timeout, wrong document format — ALWAYS log an issue:
   `form-tester issue <category> "<description of what happened>"`
   Categories: person-selection, navigation, form-fill, submission, documents, pdf-download, html-capture, screenshot, snapshot, validation, modal, timeout, other
-  Example: `form-tester issue modal "Submit showed error modal instead of success: Det skjedde en feil"`
-  Example: `form-tester issue person-selection "Person list showed 0 options, had to retry manually"`
-  These logs help us improve the skill to handle more scenarios automatically.
 - View logged issues: `form-tester issues`
-- IMPORTANT: All screenshots taken during a test run MUST use `--full-page` to capture the entire page, not just the viewport. This applies to every screenshot command: `form-tester exec screenshot --filename "..." --full-page`
-- IMPORTANT: Take a full-page screenshot EVERY TIME the page changes. This includes: after clicking any action button (Neste, Forrige, Send inn, etc.), after a step/page transition, after form validation errors appear, after modals open, and after submission. Name screenshots descriptively (e.g., step1_filled.png, step2_before_submit.png, submit_result.png).
+- IMPORTANT: All screenshots MUST use `--full-page`. Take a full-page screenshot EVERY TIME the page changes.
+
+Test flow (step by step):
 
-Test flow (when /test is triggered):
 IMPORTANT: Each prompt below MUST be asked as a separate message to the user. Wait for the user's response before proceeding to the next step. Do NOT combine multiple prompts into one message.
 
 1. Prompt for PNR (if not in URL). Wait for response.
 2. Prompt for persona (1-6 selection). Show the numbered list and wait for the user's response.
-3. Prompt for test scenario in a NEW separate message. Ask: "Any specific test scenario? (describe what to test, or Enter for standard clean test)". Wait for the user's response. If the user says nothing specific or "default" or just presses Enter, use standard test. The scenario is saved to scenario.json in the output directory.
-4. Only after receiving answers to all prompts: open browser, fill form, submit, verify.
+3. Prompt for test scenario in a NEW separate message. Wait for the user's response.
+4. Only after receiving answers to all prompts, proceed with the steps below.
+
+Step 1 — Open and setup:
+```
+form-tester test <url> --auto --pnr <pnr> --persona <id> --scenario "<text>"
+```
+
+Step 2 — Dismiss cookies:
+```
+form-tester cookies
+```
+This automatically finds and clicks the cookie banner. No-op if no banner is present.
 
-Form filling strategy:
-Before filling any fields, take a snapshot and study the FULL form structure:
+Step 3 — Select person:
+```
+form-tester select-person
+```
+This scans for available persons, selects the recommended one ("Uromantisk Direktør"), clicks it, and takes a screenshot. To select a specific person:
+```
+form-tester select-person "Navn Navnesen"
+```
+
+Step 4 — Study the form structure:
+Take a snapshot and study the FULL form before filling anything:
 1. Identify ALL sections, including collapsed/accordion sections (buttons with arrow icons).
-2. Expand ALL collapsed sections FIRST by clicking their header buttons. Take a new snapshot after expanding.
-3. Identify ALL required fields across all sections before starting to fill.
-4. Fill fields section by section, top to bottom.
+2. Expand ALL collapsed sections FIRST by clicking their header buttons.
+3. Take a new snapshot after expanding.
+4. Identify ALL required fields across all sections.
+
+Step 5 — Fill the form:
+Fill fields section by section, top to bottom. Use `form-tester exec` for all commands.
 
 Autosuggest / search fields (e.g. "Søk opp et legemiddel"):
-These fields show a dropdown with suggestions as you type. Do NOT use `fill` + `Enter` — the value won't commit.
-Instead:
+Do NOT use `fill` + `Enter` — the value won't commit. Instead:
 ```
 form-tester exec fill <ref> "search text"
 ```
-Then wait for the dropdown to appear and take a snapshot to find the suggestion element:
+Wait for the dropdown, take a snapshot to find the suggestion, then click it:
 ```
 form-tester exec snapshot
+form-tester exec click <suggestion-ref>
 ```
-Then click the correct suggestion from the dropdown list. If no dropdown appears, try:
+Or use run-code:
 ```
 form-tester exec run-code "async page => { const input = page.locator('#fieldId'); await input.fill('search text'); await page.waitForTimeout(1000); const option = page.locator('[role=\"option\"]').first(); await option.click(); }"
 ```
 
-Handling validation errors after submit:
-CRITICAL RULES — follow these exactly:
-1. MAXIMUM 3 submit attempts. If validation errors persist after 3 attempts, STOP. Log the remaining errors with `form-tester issue validation "..."` and note them in test_results.txt. Do NOT keep retrying.
-2. After each failed submit, take a snapshot and READ the validation error list carefully.
-3. Each validation error is a clickable link with an href like `#fieldId`. Click the error link to scroll to and focus the unfilled field. This is the ONLY reliable way to find the field.
-4. After clicking the error link, take a snapshot to see the field in context and fill it.
-5. Do NOT re-fill fields that are already filled. Only fix the fields listed in the validation errors.
-6. Do NOT use JavaScript `dispatchEvent` hacks or `element.evaluate()` to set values — these bypass React's state and the form won't register the value. Always use Playwright's `fill`, `click`, `select` commands.
-7. Before resubmitting, verify that the number of validation errors has decreased. If the same errors persist after you tried to fix them, the approach isn't working — try a different strategy (e.g., expand a collapsed section, use a different selector).
-8. Some forms have accordion/collapsible sections. Validation errors inside collapsed sections cannot be filled until the section is expanded. Look for buttons near the error's field ID in the snapshot and click to expand.
+Step 6 — Submit:
+Take a screenshot before submitting, then click the submit button.
 
-Post-submit verification:
+Step 7 — Handle validation errors:
+IMPORTANT: If validation errors appear after clicking submit, the form DID NOT SUBMIT. The errors are blocking submission. You must fix them first.
+
+Run the validate command to find and scroll to each error:
+```
+form-tester validate
+```
+This will:
+1. Take a snapshot and parse all validation errors
+2. Click each error link to scroll to the unfilled field
+3. Take a snapshot at each field so you can see what needs to be filled
+4. Print structured output with field IDs and error messages
+
+After `form-tester validate`, fix each field it found, then run `form-tester validate` again to confirm errors are resolved. Only then resubmit.
+
+CRITICAL RULES:
+- MAXIMUM 3 submit attempts. After 3, STOP. Log remaining errors with `form-tester issue validation "..."` and note them in test_results.txt.
+- Do NOT re-fill fields that are already filled. Only fix fields listed in validation errors.
+- Do NOT use JavaScript `dispatchEvent` hacks or `element.evaluate()` to set values — these bypass React's state. Always use Playwright's `fill`, `click`, `select` commands.
+- If the same errors persist after fixing, the field might be inside a collapsed accordion section. Expand it first.
+
+Step 8 — Post-submit verification:
 After a successful submission, read the modal text carefully:
-- If it says the form is stored in Dokumenter (e.g. "En kopi er også lagret i Dokumenter" or "Skjemaet er fullført og lagret i Dokumenter"), proceed with Dokumenter verification below.
-- If the modal does NOT mention Dokumenter, or says the form will not be stored/you will not get a response, skip Dokumenter verification entirely. Record this in test_results.txt.
+- If it says the form is stored in Dokumenter (e.g. "lagret i Dokumenter"), proceed with Dokumenter verification.
+- If the modal does NOT mention Dokumenter, skip Dokumenter verification. Record this in test_results.txt.
 
-Dokumenter verification (only when modal confirms storage):
-Use the standardized documents command — it handles navigation, format detection, PDF download, and HTML capture automatically:
+Step 9 — Dokumenter verification (only when modal confirms storage):
 ```
 form-tester documents
 ```
-This will:
-1. Navigate to `/dokumenter?pnr={PNR}`
-2. Click "Se detaljer" on the first document
-3. Click "Åpne dokumentet"
-4. Auto-detect PDF vs HTML format
-5. Download PDF or capture HTML screenshot + raw HTML
-6. Log issues automatically if any step fails
-
-If `form-tester documents` doesn't find the right elements (logged as issues), fall back to manual steps:
-1. Navigate to `/dokumenter?pnr={PNR}` and select the same person used during form fill.
-2. The document list loads sorted newest first. The first entry should match the form title.
-3. Click "Se detaljer" on the first document, then click "Åpne dokumentet".
-4. After clicking "Åpne dokumentet", determine the document format:
-
-   How to detect format:
-   - Take a snapshot: `form-tester exec snapshot`
-   - If snapshot shows a link with href containing `/pdf/` or `blob:` → PDF
-   - If `--full-page` screenshot times out → PDF (do NOT retry, switch to download)
-   - If snapshot shows rendered HTML content (headings, paragraphs, form data) → HTML
-
-   PDF documents — DOWNLOAD, do NOT screenshot:
-   IMPORTANT: `run-code` does NOT have access to `require` or `fs`. Do NOT use `require('fs')`. Use Playwright's download API instead.
-
-   Find the PDF download link in the snapshot (look for `a[href*="/pdf/"]` or "Last ned" link), then download using the Playwright download event:
+This handles the full flow: navigate to Dokumenter, find latest doc, detect format, download PDF or screenshot HTML.
+
+If `form-tester documents` fails (logged as issues), fall back to manual steps:
+1. Navigate to `/dokumenter?pnr={PNR}` and select the same person.
+2. Click "Se detaljer" on the first document, then "Åpne dokumentet".
+3. Detect format from snapshot:
+   - `a[href*="/pdf/"]` or `blob:` → PDF
+   - `--full-page` screenshot times out → PDF
+   - Rendered HTML content → HTML
+
+   PDF — download:
    ```
    form-tester exec run-code "async page => { const link = page.locator('a[href*=\"/pdf/\"]').first(); const [download] = await Promise.all([ page.waitForEvent('download'), link.click() ]); await download.saveAs('$OUTPUT_DIR/document.pdf'); }"
    ```
-   If there is no direct PDF link but a "Last ned" button:
-   ```
-   form-tester exec run-code "async page => { const [download] = await Promise.all([ page.waitForEvent('download'), page.getByRole('link', { name: 'Last ned' }).click() ]); await download.saveAs('$OUTPUT_DIR/document.pdf'); }"
-   ```
-   Verify the download: check that document.pdf exists in the output folder.
 
-   HTML documents — SCREENSHOT full page:
+   HTML — screenshot + save:
    ```
    form-tester exec screenshot --filename "$OUTPUT_DIR/document_screenshot.png" --full-page
+   form-tester exec eval "document.documentElement.outerHTML"
    ```
-   Also save raw HTML: `form-tester exec eval "document.documentElement.outerHTML"` → save to document.html.
-
-   XML/other: Note type in test_results.txt, skip capture.
 
-5. Log any issues encountered: `form-tester issue documents "description of what went wrong"`
-6. Include the document verification results in test_results.txt (document title, whether it matched the form h1, document type: HTML/PDF/XML).
+Step 10 — Finalize:
+- Write test_results.txt with status, data used, and notes.
+- Close browser: `form-tester exec close`

package/.claude/skills/form-tester/SKILL.md

@@ -47,21 +47,31 @@ Replay a previous run:
 form-tester replay output/form-id/timestamp/recording.json
 ```
 
-## Document verification
+## Standardized commands
+
+Use these instead of manual steps — they handle retries, edge cases, and error logging automatically:
 
-After form submission, use the standardized documents command:
 ```bash
-form-tester documents        # auto-navigates, detects PDF/HTML, captures
+form-tester cookies                    # dismiss cookie banner (tries known selectors)
+form-tester select-person              # select recommended person ("Uromantisk Direktør")
+form-tester select-person "Name"       # select specific person by name
+form-tester validate                   # parse validation errors, scroll to each field, show context
+form-tester documents                  # navigate to Dokumenter, detect PDF/HTML, capture
+form-tester issue <category> "<text>"  # log an issue for skill improvement
+form-tester issues                     # view recent issues
 ```
-This handles the full flow: navigate to Dokumenter, find latest doc, detect format, download PDF or screenshot HTML.
+
+### Typical test flow:
+1. `form-tester test <url> --auto` — open form
+2. `form-tester cookies` — dismiss cookies
+3. `form-tester select-person` — select person
+4. Fill the form with `form-tester exec fill/click/select`
+5. Submit, then `form-tester validate` — find and fix any validation errors
+6. `form-tester documents` — verify document after successful submission
+7. `form-tester exec close` — finalize recording
 
 ## Issue logging
 
-When something unexpected happens during a test, log it for skill improvement:
-```bash
-form-tester issue <category> "<description>"
-form-tester issues              # view recent issues
-```
 Categories: `person-selection`, `navigation`, `form-fill`, `submission`, `documents`, `pdf-download`, `html-capture`, `screenshot`, `snapshot`, `validation`, `modal`, `timeout`, `other`
 
 ## Interactive commands

package/form-tester.js

@@ -7,7 +7,7 @@ const { spawn, execSync } = require("child_process");
 const CONFIG_PATH = path.join(process.cwd(), "form-tester.config.json");
 const OUTPUT_BASE = path.resolve(process.cwd(), "output");
 const ISSUES_PATH = path.join(OUTPUT_BASE, "issues.jsonl");
-const LOCAL_VERSION = "0.9.1";
+const LOCAL_VERSION = "0.10.0";
 const RECOMMENDED_PERSON = "Uromantisk Direktør";
 
 // Recording — persisted to disk so `form-tester exec` can append across processes
@@ -257,6 +257,268 @@ async function handleDocuments(config, flags = {}) {
   return 0;
 }
 
+// --- Standardized commands: cookies, select-person, validate ---
+
+async function handleCookies() {
+  // Try known cookie banner selectors
+  const script = `() => {
+    const selectors = [
+      '[data-testid="reject-all-cookies"]',
+      '[data-testid="accept-all-cookies"]',
+      'button[id*="cookie" i]',
+      'button[class*="cookie" i]',
+      '[data-testid*="cookie" i]',
+      'button:has-text("Avvis alle")',
+      'button:has-text("Reject")',
+      'button:has-text("Aksepter")',
+    ];
+    for (const sel of selectors) {
+      const el = document.querySelector(sel);
+      if (el && el.offsetParent !== null) {
+        el.click();
+        return { found: true, selector: sel, text: (el.textContent || "").trim().substring(0, 60) };
+      }
+    }
+    return { found: false };
+  }`;
+  const result = await runPlaywrightCliCapture(["eval", script]);
+  const output = result.stdout.replace(/^### Result\s*/i, "").trim();
+  try {
+    const parsed = JSON.parse(output);
+    if (parsed.found) {
+      console.log(`Cookie banner dismissed: "${parsed.text}" (${parsed.selector})`);
+      return 0;
+    }
+  } catch (e) {
+    // parse failed, check raw output
+  }
+  console.log("No cookie banner found.");
+  return 0;
+}
+
+async function handleSelectPerson(config, targetName) {
+  const v = "normal";
+  const log = (msg) => console.log(msg);
+
+  // Step 1: Try to find person list from current page snapshot
+  const tmpSnapshot = path.join(
+    config.lastRunDir || OUTPUT_BASE,
+    `_person_scan_${Date.now()}.yml`,
+  );
+  await runPlaywrightCli(["snapshot", "--filename", tmpSnapshot]);
+
+  let options = extractPersonsFromSnapshotFile(tmpSnapshot);
+
+  // Step 2: If no options from snapshot, try JS-based detection
+  if (!options.length) {
+    for (let attempt = 0; attempt < 3; attempt++) {
+      log(`Scanning for person options (attempt ${attempt + 1})...`);
+      await sleep(1500);
+      options = await fetchPersonOptions();
+      if (options.length) break;
+    }
+  }
+
+  if (!options.length) {
+    console.error("No person options found on page.");
+    logIssue("person-selection", "No person options found by select-person command");
+    // Clean up temp file
+    try { fs.unlinkSync(tmpSnapshot); } catch (e) {}
+    return 1;
+  }
+
+  options = prioritizeRecommended(options, RECOMMENDED_PERSON);
+
+  // Step 3: Determine which person to select
+  let chosen;
+  if (targetName) {
+    const target = targetName.toLowerCase();
+    chosen = options.find((o) => o.toLowerCase().includes(target));
+    if (!chosen) {
+      log(`Person "${targetName}" not found. Available: ${options.join(", ")}`);
+      chosen = options[0];
+      log(`Falling back to: ${chosen}`);
+    }
+  } else {
+    chosen = options[0]; // recommended or first
+  }
+
+  // Step 4: Click the person button
+  log(`Selecting person: ${chosen}`);
+  const clickScript = `() => {
+    const buttons = Array.from(document.querySelectorAll('button, [role="button"], [role="option"], a'));
+    const normalize = (s) => (s || "").replace(/\\s+/g, " ").trim();
+    const target = ${JSON.stringify(chosen)};
+    for (const btn of buttons) {
+      const text = normalize(btn.textContent);
+      if (text.includes(target) || text === target) {
+        btn.click();
+        return { clicked: true, text: text.substring(0, 80) };
+      }
+    }
+    return { clicked: false, available: buttons.slice(0, 10).map(b => normalize(b.textContent).substring(0, 60)).filter(Boolean) };
+  }`;
+  const clickResult = await runPlaywrightCliCapture(["eval", clickScript]);
+  const clickOutput = clickResult.stdout.replace(/^### Result\s*/i, "").trim();
+  try {
+    const parsed = JSON.parse(clickOutput);
+    if (parsed.clicked) {
+      log(`Person selected: ${parsed.text}`);
+      config.lastPerson = chosen;
+      saveConfig(config);
+      await sleep(1000);
+      // Take screenshot after selection
+      if (config.lastRunDir) {
+        await runPlaywrightCli(["screenshot", "--filename", path.join(config.lastRunDir, "person_selected.png"), "--full-page"]);
+      }
+    } else {
+      log("Could not click person button. Available buttons:");
+      (parsed.available || []).forEach((b) => log(`  - ${b}`));
+      logIssue("person-selection", `Could not click "${chosen}". Buttons found but none matched.`);
+    }
+  } catch (e) {
+    log(`Person selection result: ${clickOutput}`);
+  }
+
+  // Clean up temp file
+  try { fs.unlinkSync(tmpSnapshot); } catch (e) {}
+  return 0;
+}
+
+function parseValidationErrors(snapshotText) {
+  const lines = snapshotText.split(/\r?\n/);
+  const errors = [];
+  // Look for the validation status block: status "Sjekk at følgende er riktig utfylt:"
+  let inValidation = false;
+  let validationIndent = null;
+
+  for (const line of lines) {
+    const indentMatch = line.match(/^(\s*)/);
+    const indent = indentMatch ? indentMatch[1].length : 0;
+
+    if (!inValidation) {
+      if (line.includes('status "Sjekk at følgende er riktig utfylt:"') || line.includes('status "Sjekk at f')) {
+        inValidation = true;
+        validationIndent = indent;
+      }
+      continue;
+    }
+
+    // Exit validation block when we hit same or lower indent that's not part of the list
+    if (indent <= validationIndent && !line.includes("list") && !line.includes("listitem") && !line.includes("link") && line.trim().startsWith("-")) {
+      break;
+    }
+
+    // Parse error links: link "error text" [ref=eXXX] ... /url: "#fieldId"
+    const linkMatch = line.match(/link "([^"]+)" \[ref=(e\d+)\]/);
+    if (linkMatch) {
+      const errorText = linkMatch[1];
+      const ref = linkMatch[2];
+      // Look for the URL on the next line or in the same block
+      errors.push({ text: errorText, ref, fieldId: null });
+    }
+
+    // Parse URL for the most recent error
+    const urlMatch = line.match(/\/url:\s*"#([^"]+)"/);
+    if (urlMatch && errors.length > 0 && !errors[errors.length - 1].fieldId) {
+      errors[errors.length - 1].fieldId = urlMatch[1];
+    }
+  }
+
+  return errors;
+}
+
+async function handleValidate(config) {
+  const outputDir = config.lastRunDir;
+  if (!outputDir) {
+    console.error("No output folder. Run a test first.");
+    return 1;
+  }
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  // Step 1: Take a fresh snapshot
+  const snapshotPath = path.join(outputDir, `validate_${Date.now()}.yml`);
+  await runPlaywrightCli(["snapshot", "--filename", snapshotPath]);
+
+  if (!fs.existsSync(snapshotPath)) {
+    console.error("Failed to take snapshot.");
+    return 1;
+  }
+
+  const snapshotText = fs.readFileSync(snapshotPath, "utf8");
+  const errors = parseValidationErrors(snapshotText);
+
+  if (!errors.length) {
+    console.log("No validation errors found. Form is ready to submit.");
+    return 0;
+  }
+
+  console.log(`\n${errors.length} validation error(s) found:\n`);
+
+  for (let i = 0; i < errors.length; i++) {
+    const err = errors[i];
+    const fieldId = err.fieldId ? decodeURIComponent(err.fieldId) : "unknown";
+    console.log(`  ${i + 1}. [${fieldId}] "${err.text}" (ref=${err.ref})`);
+  }
+
+  // Step 2: Click each error link to scroll to it and take a snapshot
+  console.log("\nScrolling to each error and taking snapshots...\n");
+
+  for (let i = 0; i < errors.length; i++) {
+    const err = errors[i];
+    const fieldId = err.fieldId ? decodeURIComponent(err.fieldId) : null;
+
+    // Click the error link to scroll to the field
+    const clickCode = await runPlaywrightCli(["click", err.ref]);
+    if (clickCode !== 0) {
+      console.log(`  ${i + 1}. Could not click error link ${err.ref}`);
+      continue;
+    }
+
+    await sleep(500);
+
+    // Take a snapshot focused on the field area
+    const fieldSnapshotPath = path.join(outputDir, `validation_error_${i + 1}.yml`);
+    await runPlaywrightCli(["snapshot", "--filename", fieldSnapshotPath]);
+
+    // Read the snapshot to find the field context
+    if (fs.existsSync(fieldSnapshotPath)) {
+      const fieldSnapshot = fs.readFileSync(fieldSnapshotPath, "utf8");
+
+      // Find the field in the snapshot by its ID
+      let fieldContext = "";
+      if (fieldId) {
+        const fieldLines = fieldSnapshot.split(/\r?\n/);
+        for (let j = 0; j < fieldLines.length; j++) {
+          // Look for elements with aria-invalid or the field ID
+          if (fieldLines[j].includes(`[aria-invalid`) || fieldLines[j].includes(fieldId.replace(/\./g, "%2E"))) {
+            // Grab surrounding context (5 lines before, 10 after)
+            const start = Math.max(0, j - 5);
+            const end = Math.min(fieldLines.length, j + 10);
+            fieldContext = fieldLines.slice(start, end).join("\n");
+            break;
+          }
+        }
+      }
+
+      if (fieldContext) {
+        console.log(`  ${i + 1}. [${fieldId}] "${err.text}"`);
+        console.log(`     Field context from snapshot:`);
+        console.log(fieldContext.split("\n").map((l) => `     ${l}`).join("\n"));
+        console.log("");
+      } else {
+        console.log(`  ${i + 1}. [${fieldId}] "${err.text}" — scrolled to field, see ${fieldSnapshotPath}`);
+      }
+    }
+  }
+
+  // Step 3: Scroll back to top
+  await runPlaywrightCliCapture(["eval", "window.scrollTo(0, 0)"]);
+
+  console.log(`\nFix these ${errors.length} field(s), then run 'form-tester validate' again before submitting.`);
+  return errors.length;
+}
+
 const PERSONAS = [
   {
     id: "ung-mann",
@@ -650,9 +912,12 @@ function printHelp() {
       "  form-tester test <url> --human          Interactive test with prompts",
       "  form-tester exec <command> [args]       Run playwright-cli command (recorded)",
       "  form-tester replay <recording.json>     Replay a recorded test run",
-      "  form-tester documents                   Verify document in Dokumenter (auto PDF/HTML)",
-      "  form-tester issue <category> <message>  Log an issue for skill improvement",
-      "  form-tester issues [limit]              Show recent logged issues",
+      "  form-tester cookies                      Dismiss cookie banner",
+      "  form-tester select-person [name]         Select person (recommended or by name)",
+      "  form-tester validate                     Parse validation errors, scroll to each field",
+      "  form-tester documents                    Verify document in Dokumenter (auto PDF/HTML)",
+      "  form-tester issue <category> <message>   Log an issue for skill improvement",
+      "  form-tester issues [limit]               Show recent logged issues",
       "",
       "Interactive commands:",
       "  /test {url}                 Open form URL and start test",
@@ -1543,6 +1808,24 @@ async function main() {
     process.exit(code);
   }
 
+  if (args[0] === "cookies") {
+    const code = await handleCookies();
+    process.exit(code);
+  }
+
+  if (args[0] === "select-person") {
+    const config = loadConfig();
+    const targetName = args.slice(1).join(" ") || null;
+    const code = await handleSelectPerson(config, targetName);
+    process.exit(code);
+  }
+
+  if (args[0] === "validate") {
+    const config = loadConfig();
+    const code = await handleValidate(config);
+    process.exit(code);
+  }
+
   if (args[0] === "test" && args.includes("--human")) {
     const config = loadConfig();
     const url = args.find((a) => a.startsWith("http"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "form-tester",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "AI-powered form testing skill for /skjemautfyller forms using Playwright CLI. Works with Claude Code and GitHub Copilot.",
   "main": "form-tester.js",
   "bin": {