neuron-inspector 0.3.1 → 0.4.0

package/recipes/email-outreach/recipe.yaml

@@ -0,0 +1,109 @@
+name: Email Outreach
+version: 1.0.0
+description: >
+  Opens Gmail or Outlook in the browser and sends personalized cold emails
+  using the logged-in session. No SMTP, no API keys. Researches each target,
+  finds personalization hooks, composes unique emails, and sends with human-like
+  pacing. Tracks open/reply rates and evolves subject line and body strategy.
+author: neuron
+tags: [email, outreach, gmail, outlook, cold-email, lead-gen]
+
+variables:
+  email_client:
+    prompt: "Which email client to use?"
+    options: [gmail, outlook]
+    default: gmail
+  subject_template:
+    prompt: "Subject line direction (not a template — a theme to follow)"
+    type: text
+    required: true
+    example: "Reference something specific from their company/work"
+  body_template:
+    prompt: "Email body direction (1-2 sentences describing the tone and structure, NOT a literal template)"
+    type: text
+    required: true
+    example: "Short, reference something specific, one clear ask, no 'hope this email finds you well' nonsense"
+  sender_name:
+    prompt: "Your name (for email signature)"
+    type: text
+    required: true
+    example: "Rasheed Alabi"
+  product_context:
+    prompt: "What are you reaching out about? Describe the product/service/opportunity in 2-3 sentences."
+    type: text
+    required: true
+    example: "LetsChop is a meal ordering app for Nigerian organizations — handles group food orders, vendor management, and delivery logistics."
+  audience_description:
+    prompt: "Who should you reach out to? Be specific about role, industry, location, problem they have."
+    type: text
+    required: true
+    example: "HR managers and office managers in Nigerian tech companies that deal with employee meal orders"
+  daily_cap:
+    prompt: "Max emails per day"
+    type: number
+    default: 15
+  session_cap:
+    prompt: "Max emails per session (run)"
+    type: number
+    default: 5
+  min_delay_seconds:
+    prompt: "Minimum seconds between emails"
+    type: number
+    default: 90
+  output_path:
+    prompt: "Where to save outreach logs"
+    type: path
+    default: "./email-outreach"
+  approval_mode:
+    prompt: "Review each email before sending, or auto-send after first 3?"
+    options: [review-all, auto-after-3]
+    default: review-all
+
+tools:
+  required:
+    - neuron_navigate
+    - neuron_find_elements
+    - neuron_type
+    - neuron_click
+    - neuron_scroll
+    - neuron_screenshot
+    - neuron_evaluate_js
+    - neuron_detect_blocker
+    - neuron_research_page
+    - neuron_monitor_action
+    - neuron_session_save
+    - neuron_session_load
+    - neuron_session_checkpoint
+  optional:
+    - neuron_open_tab
+    - neuron_extract_data
+    - neuron_snapshot_state
+    - neuron_diff_states
+    - neuron_search_traffic
+
+pipes:
+  outputs:
+    outreach_log:
+      format: yaml
+      path: "{{output_path}}/outreach-log.yaml"
+      description: "Running log of all emails sent — recipient, subject, body, timestamp, open/reply status"
+    email_drafts:
+      format: markdown
+      path: "{{output_path}}/drafts.md"
+      description: "Archive of all email drafts — subject lines and bodies that were sent"
+  inputs:
+    campaign_plan:
+      from: planner
+      output: plan
+      description: "Campaign plan with target list, timing strategy, and message approach"
+      optional: true
+    research_report:
+      from: web-researcher
+      output: report
+      description: "Research on target companies/individuals for personalization"
+      optional: true
+
+limits:
+  max_tabs: 3
+  max_duration_minutes: 45
+  require_human_approval: true

package/recipes/linkedin-outreach/agent.md

@@ -212,6 +212,14 @@ After 20+ messages with at least 8 response outcomes, review memory and update `
 - Which messages got negative responses? What do they have in common?
 - Which messages were rejected by the human reviewer? Why? Update the hard rules.
 
+**Rule updates from data:**
+After evolving, check if any learnings should become permanent rules:
+- Read current rules with `neuron_rules_get`
+- If a pattern consistently causes negative responses → propose a `never` rule (e.g., "never mention pricing in the first message")
+- If the human rejected messages for the same reason 3+ times → propose a `global` rule
+- If LinkedIn-specific limits were discovered → update `platform.linkedin` rules
+- Present proposed rule changes to the user and save with `neuron_rules_set` on approval
+
 Update the strategy based on data. If post-based hooks get 3x the response rate, make that the default approach. If messages under 200 characters outperform longer ones, tighten the structure. If Tuesday mornings get the best response rates, note it in the pacing section.
 
 The metric is **response rate per message**, not messages sent. A 20% response rate on 50 messages beats a 2% response rate on 500.

package/recipes/planner/agent.md

@@ -189,7 +189,32 @@ hard_boundaries:
   - "[what must not be done]"
 ```
 
-### Phase 6: Optionally generate a recipe
+### Phase 6: Update rules from findings
+
+After researching platform constraints, update the user's rules using `neuron_rules_set`.
+
+**Convert hard boundaries to "never" rules:**
+If the research found things that should absolutely never be done (e.g., "LinkedIn permanently bans accounts that send more than 200 connection requests in a day"), propose adding them as `never` rules.
+
+**Convert rate limits to platform rules:**
+Translate discovered safe operating ranges into platform-specific rules. For example, if research found LinkedIn's safe range is 50 messages/day:
+```
+neuron_rules_set({
+  platform: {
+    linkedin: [
+      "Maximum 50 messages per day (researched 2026-09-05)",
+      "Minimum 120 seconds between messages",
+      "Do not send connection requests to accounts with no profile photo"
+    ]
+  }
+})
+```
+
+**Always read existing rules first** with `neuron_rules_get` to avoid overwriting rules the user already set. Merge, don't replace.
+
+**Flag rule suggestions to the user.** Before saving, present the proposed rules and ask for confirmation. The user might have context you don't — maybe they have Sales Navigator (higher limits) or a new account (lower limits).
+
+### Phase 7: Optionally generate a recipe
 
 If `{{create_recipe}}` is "yes", use `neuron_recipe_create` to generate a new recipe based on the plan. The recipe should:
 - Have the execution steps as its Strategy

package/recipes/social-ops/agent.md

@@ -309,8 +309,28 @@ outcome:
       platform: "{{platform}}"
       context: "<what it was supposed to find>"
   session_duration_minutes: <approx>
+  rule_violations:
+    - "<any rule that was almost or actually violated, and what prevented it>"
+  proposed_rules:
+    - "<any new rule the agent thinks should be added based on this session>"
 ```
 
+### Auto-update rules from session outcomes
+
+After logging memory, check if any findings should become rules:
+
+**If a blocker was hit** (rate limit, captcha, account restriction):
+- Use `neuron_rules_get` to read current rules
+- Propose a new platform rule with the safe limit (e.g., "Maximum 25 DMs per day on Instagram — hit rate limit at 30")
+- Present the proposed rule to the user for approval
+- If approved, call `neuron_rules_set` to save it
+
+**If the human rejected an action** during the approval gate:
+- Ask why. If it's a pattern (e.g., "don't DM people with less than 100 followers"), propose it as a global or platform rule
+
+**If a selector failed:**
+- Don't make a rule — update the Platform Playbook instead
+
 ## Evolve
 
 After 10+ sessions, review memory and update `learnings.md`:
@@ -329,10 +349,17 @@ After 10+ sessions, review memory and update `learnings.md`:
 - Have any limits changed?
 - What's the actual safe operating range vs the documented limit?
 - Any new detection patterns?
+- **Update platform rules** via `neuron_rules_set` if limits have changed.
 
 **Targeting:**
 - Which target sources (post likers vs followers vs commenters vs search) yield the most receptive people?
 - Does personalization significantly improve response rates?
 - What fit score threshold is worth the effort?
 
+**Rule review:**
+- Read all proposed_rules from memory entries
+- Any pattern that appears 3+ times → propose as a permanent rule via `neuron_rules_set`
+- Any rule that was never triggered → flag as potentially unnecessary
+- Present the rule update summary to the user for approval
+
 Update the Platform Playbook with any selector changes, updated limits, or new UI patterns discovered.