neuron-inspector 0.4.2 → 0.5.0

package/recipes/inbox-responder/agent.md

@@ -0,0 +1,268 @@
+# Inbox Responder
+
+You watch inboxes for new messages, draft replies, and send them for WhatsApp approval. You don't send anything without the user's explicit approval from their phone.
+
+The loop: check inbox → find new messages → draft reply → send to WhatsApp → wait for approve/reject → send or skip.
+
+## Strategy
+
+### Phase 0: Load state
+
+1. `neuron_session_load` with session_id `inbox-responder` — check for existing state
+2. If state exists, load `last_checked` timestamps per inbox and `seen_messages` list
+3. If no state, initialize: `{ last_checked: {}, seen_messages: [] }`
+4. Read `learnings.md` for reply patterns that work
+5. Read `{{output_path}}/response-log.yaml` for history
+
+### Phase 1: Check each inbox
+
+For each inbox in `{{inboxes}}`:
+
+**IMPORTANT: Scroll to latest.** Messaging apps show conversations in reverse chronological order (newest at bottom). After opening any conversation, ALWAYS scroll to the bottom before extracting messages. Use `neuron_scroll` with a large negative `deltaY` or use `neuron_evaluate_js` to scroll the message container to its `scrollHeight`. Without this, you'll read old messages and miss the most recent one.
+
+#### LinkedIn
+
+1. `neuron_focus_tab` on any existing LinkedIn tab, or `neuron_navigate` to `https://www.linkedin.com/messaging/`
+2. Wait 3 seconds for the page to load
+3. `neuron_extract_data` with selector `.msg-conversation-listitem` to get the conversation list
+4. Look for unread indicators: elements with `.msg-conversation-card__unread-count` or bold text styling
+5. For each unread conversation:
+   - `neuron_click` with `texts: ["<person name>"]` to open it
+   - **Scroll to latest:** `neuron_scroll` with `selector: ".msg-s-message-list-container"` to scroll the message list to the bottom, OR `neuron_evaluate_js` with `document.querySelector('.msg-s-message-list-container').scrollTop = document.querySelector('.msg-s-message-list-container').scrollHeight`
+   - Wait 1 second for lazy-loaded messages to render
+   - `neuron_extract_data` with selector `.msg-s-event-listitem` to read messages
+   - The LAST items in the extracted list are the most recent — read from the bottom
+   - Extract: sender name, their message text, timestamp
+   - Check against `seen_messages` — skip if already processed
+   - Check against `{{auto_skip}}` patterns — skip newsletters, automated messages
+   - Add to the `new_messages` queue
+
+#### Gmail
+
+1. `neuron_focus_tab` on any existing Gmail tab, or `neuron_navigate` to `{{gmail_url}}`
+2. Wait 3 seconds for load
+3. `neuron_extract_data` with selector `tr.zE` (unread rows in Gmail) or `tr.zA` (all rows, unread have `zE` class)
+4. For each unread email:
+   - `neuron_click` to open it
+   - **Scroll to latest:** `neuron_scroll` with `deltaY: 99999` to reach the bottom of the email thread (shows most recent reply)
+   - Wait 1 second
+   - `neuron_extract_data` to read: sender, subject, body of the latest message in the thread
+   - Check against `seen_messages` and `{{auto_skip}}`
+   - Add to `new_messages` queue
+
+#### X / Twitter DMs
+
+1. `neuron_focus_tab` or `neuron_navigate` to `https://x.com/messages`
+2. Wait 3 seconds for load
+3. `neuron_extract_data` on the conversation list — look for unread indicators (bold text, dot badge)
+4. For each unread conversation:
+   - `neuron_click` to open it
+   - **Scroll to latest:** `neuron_scroll` with `selector: "[data-testid='DmScrollerContainer']"` or scroll the message container to bottom
+   - Wait 1 second
+   - `neuron_extract_data` on the message list
+   - Extract the last message (bottom of list = most recent)
+   - Check against `seen_messages` and `{{auto_skip}}`
+   - Add to `new_messages` queue
+
+#### Instagram DMs
+
+1. `neuron_focus_tab` or `neuron_navigate` to `https://www.instagram.com/direct/inbox/`
+2. Wait 3 seconds for load
+3. `neuron_extract_data` on the conversation list — look for unread indicators
+4. For each unread conversation:
+   - `neuron_click` to open it
+   - **Scroll to latest:** `neuron_scroll` with `deltaY: 99999` to bottom of message thread
+   - Wait 1 second
+   - `neuron_extract_data` on the message list
+   - Most recent message is at the bottom
+   - Check against `seen_messages` and `{{auto_skip}}`
+   - Add to `new_messages` queue
+
+#### TikTok DMs
+
+1. `neuron_focus_tab` or `neuron_navigate` to `https://www.tiktok.com/messages`
+2. Wait 3 seconds for load
+3. `neuron_extract_data` on the conversation list
+4. For each unread conversation:
+   - `neuron_click` to open it
+   - **Scroll to latest:** `neuron_scroll` with `deltaY: 99999` to bottom
+   - Wait 1 second
+   - `neuron_extract_data` on the message list
+   - Check against `seen_messages` and `{{auto_skip}}`
+   - Add to `new_messages` queue
+
+### Phase 2: Draft replies
+
+For each message in `new_messages`:
+
+1. Read the full message context (their message + any prior conversation if visible)
+
+2. Draft a reply based on `{{reply_style}}`:
+   - **match-their-tone**: If they're casual, reply casual. If formal, match it. Mirror their energy.
+   - **professional**: Clean, respectful, direct. No slang.
+   - **casual**: Friendly, short, like texting a colleague.
+   - **brief**: 1-2 sentences max. Acknowledge and respond.
+
+3. Use `{{context_notes}}` to inform the reply — know who you are, what you're working on, what your priorities are.
+
+4. Rules for drafting:
+   - Keep it short — match or be shorter than their message length
+   - Answer their question directly if they asked one
+   - If they're pitching you something, be polite but non-committal: "Thanks for sharing — I'll take a look"
+   - If they're following up, acknowledge it: "Noted, I'll get back to you on this"
+   - If it's a greeting/networking message, be warm but brief
+   - Never write anything you wouldn't want screenshotted and shared
+   - No AI-sounding language — no "I hope this message finds you well", no em dashes, no "I'd be happy to"
+
+### Phase 3: Approve via WhatsApp
+
+For each drafted reply:
+
+1. `neuron_approve_via_whatsapp` with:
+   - `phone`: `{{approval_phone}}`
+   - `api_key`: `{{neuron_api_key}}`
+   - `prompt`: A clear summary for the phone screen:
+     ```
+     New [platform] message from [sender]:
+     "[their message, truncated to 200 chars]"
+
+     Drafted reply:
+     "[your draft]"
+
+     Approve to send, reject to skip.
+     ```
+   - `context`: The full message thread for reference
+   - `timeout_seconds`: 300 (5 minutes — if no response, skip for now)
+
+2. Wait for the response:
+   - **approved**: Proceed to Phase 4 (send)
+   - **rejected**: Skip this message, log as rejected. If the rejection includes a reason, learn from it.
+   - **timeout**: Skip for now, will retry next check
+
+### Phase 4: Send approved replies
+
+For each approved reply:
+
+1. `neuron_focus_tab` on the inbox tab
+
+2. Navigate back to the conversation if not already there
+
+3. **LinkedIn:**
+   - `neuron_click` to open the conversation
+   - `neuron_scroll` to bottom of conversation so compose box is visible
+   - `neuron_type` with selectors `[".msg-form__contenteditable", "[contenteditable='true'][role='textbox']"]`
+   - `neuron_press_key` with key `Enter`
+   - Wait 2 seconds
+   - `neuron_extract_data` on the last message to verify your reply appeared
+
+4. **Gmail:**
+   - Open the email thread
+   - `neuron_scroll` to bottom of thread
+   - `neuron_click` on "Reply" button (texts: `["Reply"]`)
+   - Wait 2 seconds for the reply composer to load
+   - `neuron_find_elements` for `div[aria-label="Message Body"]` or `div[contenteditable='true']` — wait until found
+   - `neuron_type` the reply
+   - `neuron_click` on Send button (selectors: `["div[aria-label*='Send']", "button[aria-label*='Send']"]`)
+   - Wait 2 seconds, verify "Message sent" or the reply appears in the thread
+
+5. **X DMs:**
+   - Open the conversation
+   - `neuron_scroll` to bottom
+   - `neuron_type` into `div[data-testid="dmComposerTextInput"]` or `div[role="textbox"]`
+   - `neuron_press_key` Enter
+   - Wait 1 second, verify
+
+6. **Instagram DMs:**
+   - Open the conversation
+   - `neuron_scroll` to bottom
+   - `neuron_type` into `textarea[placeholder*="Message"]` or `div[contenteditable="true"][role="textbox"]`
+   - `neuron_press_key` Enter
+   - Wait 1 second, verify
+
+7. **TikTok DMs:**
+   - Open the conversation
+   - `neuron_scroll` to bottom
+   - `neuron_type` into the message input (try `div[contenteditable="true"]`, `textarea`)
+   - `neuron_press_key` Enter
+   - Wait 1 second, verify
+
+### Phase 5: Log and checkpoint
+
+After processing all messages:
+
+1. Update `seen_messages` with all processed message IDs/content hashes
+2. Update `last_checked` timestamps per inbox
+3. `neuron_session_save` with the updated state
+4. Append to `{{output_path}}/response-log.yaml`:
+
+```yaml
+- date: "{{now}}"
+  inbox: "<platform>"
+  sender: "<name>"
+  their_message: "<text>"
+  draft: "<your drafted reply>"
+  approval_status: approved|rejected|timeout
+  rejection_reason: "<if rejected, why>"
+  sent: true|false
+  send_verified: true|false
+```
+
+### Scheduling
+
+To run this automatically, the user should schedule it:
+
+```
+neuron_schedule_recipe({
+  slug: "inbox-responder",
+  interval_minutes: {{check_interval_minutes}},
+  variables: { ... },
+  enabled: true
+})
+```
+
+Each scheduled run: check all inboxes → draft → approve → send → sleep until next run.
+
+## Reflect
+
+After each run:
+
+```yaml
+date: {{now}}
+outcome:
+  inboxes_checked: [<list>]
+  new_messages_found: <count>
+  drafts_sent_for_approval: <count>
+  approved: <count>
+  rejected: <count>
+  timed_out: <count>
+  successfully_sent: <count>
+  send_failures: <count>
+  skip_auto: <count, skipped by auto_skip patterns>
+  duration_minutes: <approx>
+  rejection_reasons:
+    - "<why was a draft rejected>"
+```
+
+## Evolve
+
+After 20+ runs with 10+ approval outcomes:
+
+**Draft quality:**
+- Which drafts get approved vs rejected? What's different about them?
+- Are certain message types (questions, pitches, follow-ups) harder to draft well?
+- Does reply length correlate with approval rate?
+- Update `{{reply_style}}` defaults based on what gets approved.
+
+**Auto-skip refinement:**
+- Are there senders or message patterns that always get skipped manually? Add to `{{auto_skip}}`.
+- Are there messages being auto-skipped that shouldn't be?
+
+**Timing:**
+- Is `{{check_interval_minutes}}` right? Too frequent = checking empty inboxes. Too rare = slow responses.
+- Which inboxes get the most new messages?
+
+**Rejection patterns:**
+- If drafts are consistently rejected with "too formal" or "too long", update the style guidance.
+- If certain reply patterns are always edited before sending, learn the edits.
+
+Update learnings based on the data. The goal: drafts that get approved on first try, no unnecessary checks, no important messages missed.

package/recipes/inbox-responder/learnings.md

@@ -0,0 +1,25 @@
+# Learnings
+
+No runs yet. This file updates after 20+ runs with 10+ approval outcomes.
+
+## Reply Defaults
+
+- Match the sender's message length — don't write a paragraph to reply to one sentence
+- Answer the question first, then add context if needed
+- For pitches/cold outreach: "Thanks for sharing — I'll take a look" is almost always the right reply
+- For follow-ups: acknowledge, give a timeline or say you'll get back to them
+- For greetings: brief and warm, don't over-invest
+
+## Platform Quirks
+
+- LinkedIn: Enter-to-send by default. Use neuron_press_key("Enter") after typing.
+- Gmail: Reply composer lazy-loads. Wait for the contenteditable to appear before typing.
+- X DMs: Enter sends. Similar to LinkedIn flow.
+- Instagram: textarea-based input, Enter sends.
+
+## Auto-Skip Patterns
+
+Starting list (expand from rejection data):
+- newsletter, no-reply, noreply, automated, unsubscribe
+- "This is an automated message"
+- Sender names containing "bot", "support", "notifications"

package/recipes/inbox-responder/recipe.yaml

@@ -0,0 +1,82 @@
+name: Inbox Responder
+version: 1.0.0
+description: >
+  Watches your inboxes (LinkedIn, Gmail, X, Instagram DMs) for new messages,
+  drafts context-aware replies, sends them to your WhatsApp for approval, and
+  sends the reply on approval. Runs on a schedule — check every N minutes,
+  draft, approve from your phone, done.
+author: neuron
+tags: [inbox, auto-reply, whatsapp-approval, linkedin, gmail, x, instagram, monitoring]
+
+variables:
+  inboxes:
+    prompt: "Which inboxes to watch (comma-separated: linkedin, gmail, x, instagram, tiktok)"
+    type: text
+    required: true
+    example: "linkedin, gmail, x, instagram, tiktok"
+  check_interval_minutes:
+    prompt: "How often to check for new messages (minutes)"
+    type: number
+    default: 10
+  approval_phone:
+    prompt: "Your WhatsApp number for approval requests (E.164 format)"
+    type: text
+    required: true
+    example: "+2348012345678"
+  neuron_api_key:
+    prompt: "Neuron bot API key (nrn_...) for sending WhatsApp approvals"
+    type: text
+    required: true
+  reply_style:
+    prompt: "How should replies be written?"
+    options: [match-their-tone, professional, casual, brief]
+    default: match-their-tone
+  auto_skip:
+    prompt: "Messages to skip (comma-separated keywords or patterns)"
+    type: text
+    default: "newsletter, no-reply, noreply, automated, unsubscribe"
+  context_notes:
+    prompt: "Context about you that helps draft better replies (role, company, current priorities)"
+    type: text
+    default: ""
+  gmail_url:
+    prompt: "Gmail URL"
+    type: text
+    default: "https://mail.google.com/mail/u/0/#inbox"
+  output_path:
+    prompt: "Where to save response logs"
+    type: path
+    default: "./inbox-responses"
+
+tools:
+  required:
+    - neuron_navigate
+    - neuron_focus_tab
+    - neuron_extract_data
+    - neuron_find_elements
+    - neuron_type
+    - neuron_press_key
+    - neuron_click
+    - neuron_scroll
+    - neuron_screenshot
+    - neuron_evaluate_js
+    - neuron_list_tabs
+    - neuron_get_errors
+    - neuron_research_page
+    - neuron_approve_via_whatsapp
+    - neuron_session_save
+    - neuron_session_load
+    - neuron_session_checkpoint
+    - neuron_schedule_recipe
+
+pipes:
+  outputs:
+    response_log:
+      format: yaml
+      path: "{{output_path}}/response-log.yaml"
+      description: "Log of all messages received, drafts sent for approval, and responses sent"
+
+limits:
+  max_tabs: 4
+  max_duration_minutes: 15
+  require_human_approval: true

package/recipes/planner/agent.md

@@ -75,7 +75,54 @@ Search the web for outreach effectiveness data:
 
 From `learnings.md`, incorporate any patterns from past planning sessions.
 
-### Phase 5: Build the plan
+### Phase 5: Pre-mortem — how will execution fail?
+
+This is the most important phase. Before writing the plan, walk through every execution step and ask: **what will go wrong here?** Plans fail at the mechanical level, not the strategic level.
+
+**For every step the agent will perform, answer these questions:**
+
+1. **Page structure:** How does this page actually work?
+   - Is it a SPA that lazy-loads content? → The agent needs to scroll and wait before extracting.
+   - Does it use infinite scroll? → The agent needs to scroll to find the right content, not just read what's visible.
+   - Are the newest items at the top or the bottom? → Chat/messaging apps show newest at the bottom. Feeds show newest at the top. Getting this wrong means the agent reads stale data.
+   - Does the page require a click to expand content (modals, accordions, "Show more")? → Plan the click before the extract.
+
+2. **Tab focus:** Will the tab be in the foreground when the agent interacts with it?
+   - LinkedIn, Gmail, Facebook, and most modern apps render buttons and dropdowns at zero dimensions in background tabs.
+   - If the agent opens multiple tabs, only one is in the foreground. Every click/type/submit must be preceded by `neuron_focus_tab`.
+   - Any step involving send/submit/click MUST have "focus tab first" in the plan.
+
+3. **Framework compatibility:** How does the page handle input?
+   - Does it use React, Ember, Angular, or Vue? → Direct property assignment (`el.value = x`) is invisible to these frameworks. The agent must use `neuron_type` (which uses `execCommand` for contenteditable and native setters for inputs).
+   - Does the page use Enter-to-send or a Send button? → If Enter-to-send, plan `neuron_press_key("Enter")` after typing. If Send button, plan `neuron_click`.
+   - Does the page block JavaScript eval via CSP? → LinkedIn does. Facebook likely does. Don't plan steps that rely on `neuron_evaluate_js` for these platforms. Use `neuron_click`, `neuron_type`, and `neuron_press_key` instead.
+
+4. **Timing and loading:** What needs to load before the agent can act?
+   - Rich text editors (Gmail compose, LinkedIn message box) lazy-load. The agent must wait for the contenteditable element to appear before typing.
+   - Search results take time to render after submitting a query. Plan a wait.
+   - Page navigations need 2-3 seconds before extraction is reliable.
+   - After clicking a button (like Reply or Compose), plan a wait for the resulting UI to render.
+
+5. **Verification:** How will the agent know the action succeeded?
+   - "Click Send" is not verification. Verification is: extract the conversation after sending and confirm the message appears.
+   - "Type into the form" is not verification. Verification is: the form field shows the text AND the submit button is enabled.
+   - Plan a verification step after every critical action. If the verification fails, plan what to do (retry, skip, alert the user).
+
+6. **Edge cases that always happen:**
+   - What if there are no new messages? → Don't error, just report "no new messages" and exit.
+   - What if the user is logged out? → Detect the login page before trying to interact. Plan for `neuron_detect_blocker`.
+   - What if a captcha appears? → Stop immediately, alert the user. Never try to solve captchas.
+   - What if the page layout has changed since the selectors were written? → Fall back to `neuron_find_elements` with visible text matching. Text ("Send", "Reply", "Message") is more stable than CSS classes.
+   - What if there are too many results and the agent runs out of time? → Set a hard cap per run.
+
+**For every selector in the plan, answer:**
+- Is this a CSS class that the platform could rename? → Also plan a text-based fallback.
+- Is this a `data-testid` that's stable? → Better, but still verify it exists before clicking.
+- Can `neuron_find_elements` with `texts: ["Button Label"]` find this instead? → Usually more reliable.
+
+**Write the pre-mortem into the plan** as a "Known Failure Modes" section with mitigations for each. This isn't optional — a plan without failure modes is a wish list.
+
+### Phase 6: Build the plan
 
 Produce `{{output_path}}/{{date}}-{{goal_slug}}.md`:
 
@@ -151,6 +198,24 @@ Produce `{{output_path}}/{{date}}-{{goal_slug}}.md`:
 1. [Step-by-step, referencing specific browser tools]
 2. [Each step should map to a neuron_* tool call]
 3. [Include the warm-up / research phase per target]
+4. [Each step that involves clicking or typing MUST include neuron_focus_tab first]
+5. [Each step that reads messages/content MUST scroll to load the latest]
+6. [Each critical action MUST have a verification step after it]
+
+## Known Failure Modes
+
+For each failure mode, state: what fails, why, how the agent detects it, and what it does instead.
+
+| Failure | Detection | Mitigation |
+|---------|-----------|------------|
+| [e.g., Tab in background — send button at zero dimensions] | [neuron_find_elements returns empty or element has zero size] | [neuron_focus_tab before every interaction] |
+| [e.g., CSP blocks evaluateJS on this platform] | [evaluateJS returns CSP error] | [Use neuron_click + neuron_type + neuron_press_key instead] |
+| [e.g., Newest messages at bottom, agent reads top] | [Extracted messages have old timestamps] | [neuron_scroll to bottom before extracting] |
+| [e.g., Framework doesn't detect typed text, buttons stay disabled] | [Send button still disabled after typing] | [neuron_type uses execCommand internally; if still broken, try neuron_press_key Tab to trigger blur/change] |
+| [e.g., Logged out / session expired] | [neuron_detect_blocker finds login wall] | [Stop run, alert user, do not retry] |
+| [e.g., Captcha or rate limit] | [neuron_detect_blocker finds captcha] | [Stop entire session immediately] |
+| [e.g., Page layout changed, selectors broken] | [neuron_find_elements with CSS selector returns empty] | [Fall back to neuron_find_elements with texts: ["Button Label"]] |
+| [e.g., Content lazy-loads after scroll] | [First extraction returns fewer items than expected] | [Scroll + wait 1-2s + re-extract] |
 
 ## Success Metrics
 

package/recipes/planner/learnings.md

@@ -1,6 +1,6 @@
 # Learnings
 
-No planning sessions yet. This file updates after 5+ plans.
+Updated 2026-09-05 from first live execution failures.
 
 ## Platform Research Defaults
 
@@ -25,3 +25,51 @@ Starting assumptions (to be validated by actual research each session):
 - Action blocks last 24-48 hours
 
 These are starting points. ALWAYS research current limits during Phase 2.
+
+## Execution Failures — Confirmed (2026-09-05 live testing)
+
+These are real failures that occurred during the first live test. Every plan MUST account for them.
+
+### Background tab interaction (CRITICAL)
+**What happened:** Agent clicked Send on LinkedIn and Gmail. Both reported success. Neither actually sent — buttons and dropdowns render at zero dimensions in background tabs.
+**Fix:** EVERY plan step that clicks, types, or submits MUST include `neuron_focus_tab` first. No exceptions.
+
+### Framework change detection (CRITICAL)
+**What happened:** Agent typed a message into LinkedIn's compose box. The text appeared visually, but LinkedIn's Ember.js framework didn't detect it — the Send button stayed disabled.
+**Why:** Direct DOM property assignment (`el.value = x`, `el.textContent = x`) is invisible to React/Ember/Angular/Vue. These frameworks use their own state management and only detect input from native browser events.
+**Fix:** `neuron_type` now uses `document.execCommand("insertText")` for contenteditable and native prototype setters for inputs. Plans should NOT rely on `neuron_evaluate_js` for typing.
+
+### CSP blocking eval (HIGH)
+**What happened:** Agent tried to dispatch keyboard events via `neuron_evaluate_js` on LinkedIn. CSP blocked it: `unsafe-eval` not allowed.
+**Which platforms block eval:** LinkedIn (confirmed). Facebook, Instagram likely.
+**Fix:** Never plan steps that use `neuron_evaluate_js` for interaction on social platforms. Use `neuron_click`, `neuron_type`, `neuron_press_key` instead.
+
+### Scroll direction for messages (HIGH)
+**What happened:** Agent extracted messages from a LinkedIn conversation. It read the first messages in the DOM — which were OLD messages from the top. The most recent message (the one to reply to) was at the bottom, off-screen.
+**Why:** All messaging apps (LinkedIn, Gmail threads, X DMs, IG DMs, TikTok DMs) show newest messages at the bottom. The agent must scroll to the bottom before extracting.
+**Fix:** Every plan step that reads messages MUST include "scroll to bottom of conversation" before extracting.
+
+### Send verification (MEDIUM)
+**What happened:** Agent claimed "message sent" without verifying. The message was actually still in the compose box.
+**Fix:** After every send action, plan a verification step: wait 1-2 seconds, then extract the conversation and confirm the new message appears. If it doesn't, the send failed.
+
+### Lazy-loading content (MEDIUM)
+**What happened:** Gmail's reply composer didn't exist when the agent tried to type into it. The composer loads asynchronously after clicking Reply.
+**Fix:** After any action that triggers new UI (clicking Reply, Compose, opening a modal), plan a wait + `neuron_find_elements` to confirm the target element exists before interacting with it. Don't assume it's there immediately.
+
+### Chrome sideload path confusion (LOW)
+**What happened:** Chrome was loading an old extension build from a stale directory. The TOOL_CALL handler didn't exist in the old build.
+**Fix:** Verify the extension version before starting any plan. `neuron_diagnose` returns the extension status.
+
+## Pre-mortem Checklist
+
+Every plan should be checked against this list before finalizing:
+
+- [ ] Every click/type/submit step has `neuron_focus_tab` before it
+- [ ] Every message-reading step scrolls to bottom first
+- [ ] No `neuron_evaluate_js` for interaction on CSP-heavy platforms (LinkedIn, Facebook, Instagram)
+- [ ] Every send/submit step has a verification step after it
+- [ ] Every step that triggers new UI has a wait + find before interacting with the new UI
+- [ ] Login/auth state is checked before starting (neuron_detect_blocker)
+- [ ] There's a plan for what happens if a captcha appears (answer: stop everything)
+- [ ] Selectors have text-based fallbacks for platform DOM changes