@sellable/mcp 0.1.0

package/skills/campaign-messages/SKILL.md

@@ -0,0 +1,173 @@
+---
+name: campaign-messages
+description: Review leads in a campaign and craft/update messages with research.
+visibility: internal
+---
+
+# Campaign Messages
+
+Use this command when the user provides a campaignId and wants to research + craft messages for leads already imported into a campaign workflow table.
+
+## Bootstrap (Required)
+
+1. Load tools in a SINGLE message with ToolSearch calls:
+   - `mcp__sellable__get_auth_status`
+   - `mcp__sellable__get_campaign`
+   - `mcp__sellable__get_campaign_messages_preview`
+   - `mcp__sellable__get_table_rows`
+   - `mcp__sellable__get_rows`
+   - `mcp__sellable__get_message_prompt`
+   - `mcp__sellable__update_cell`
+   - `mcp__sellable__get_subskill_prompt`
+   - `mcp__sellable__search_subskill_prompts`
+2. Call `get_auth_status({})` and store as `auth`.
+3. If `auth.ok !== true`, stop and show:
+   - `auth.error.message`
+   - `auth.error.guidance`
+4. Call `get_subskill_prompt({ subskillName: "craft-message" })` and store as `craftPrompt`.
+
+## Flow (Source of Truth)
+
+Follow the flow in `mcp/sellable/skills/campaign-messages/flow.v1.json`.
+
+```json
+{
+  "version": "v1",
+  "workflow": "campaign-messages",
+  "events": [
+    "leads_selected",
+    "drafts_ready",
+    "messages_saved",
+    "approval_complete"
+  ],
+  "steps": [
+    "load-preview",
+    "draft-messages",
+    "save-messages",
+    "approve-messages",
+    "done"
+  ]
+}
+```
+
+## Tools
+
+- `mcp__sellable__get_campaign`
+- `mcp__sellable__get_campaign_messages_preview`
+- `mcp__sellable__get_rows`
+- `mcp__sellable__get_message_prompt`
+- `mcp__sellable__update_cell`
+- `WebSearch`
+- `mcp__sellable__fetch_linkedin_profile` (optional, costs credits)
+- `mcp__sellable__fetch_linkedin_posts` (optional, costs credits)
+- `mcp__sellable__fetch_company` (optional, costs credits)
+- `Task` (parallel subagents for batch)
+
+## Flow
+
+### 1) Load Campaign + Lead Preview
+
+1. Extract `campaignId` (pattern: `cmp_...`). If missing, ask for it.
+2. Call `get_campaign({ campaignId })`.
+3. Immediately fetch the first page preview (no filters yet):
+
+`get_campaign_messages_preview({ campaignId, tableId: workflowTableId, leadLimit: 25, page: 1 })`.
+
+Then render the ASCII table and stats. After that, ask if they want to filter or page.
+
+5. Render an ASCII table with the preview rows (show message previews, not checkmarks):
+
+```
+# | Name | Title | Company | Message | Approved?
+1 | ...  | ...   | ...     | Hi ...  | ✓/✗
+```
+
+Use `messagePreview` for the Message column (show "—" if empty). Keep Approved as a checkmark based on `isApproved`.
+
+If `stats` are present in the preview response, summarize them explicitly using ONLY these fields:
+
+- totalRows
+- messagesCount
+- approvedCount
+- needsApprovalCount
+- enrichedCount
+- needsEnrichCount
+
+Never mention "pending" or "sent" here (those are campaign-level stats, not workflow-table stats). Never infer whole-table counts from the current page. Only claim "all approved" if `approvedCount === totalRows` and `messagesCount === totalRows`. If stats are missing, say "Showing page X of Y (page-only preview)".
+
+Then ask: “Which leads should I craft messages for? (e.g., 1,3 or all)”
+
+If they want filters, translate into filters using real column names from the table meta. Example:
+
+`filters: [{ "column": "Message", "op": "is_empty" }, { "column": "Approved", "op": "eq", "value": false }]`
+
+Then call:
+
+`get_campaign_messages_preview({ campaignId, tableId: workflowTableId, leadLimit: 25, page: 1, filters })`.
+
+If the user asks for more rows:
+
+- Always page with `get_campaign_messages_preview({ campaignId, tableId, leadLimit, page, filters })` so stats and filters stay consistent.
+- Use `get_table_rows` only when the user explicitly asks for the raw table rows tool.
+
+Then re-render the ASCII table for that page and ask which rows to craft.
+
+### Optional Research Toggle
+
+Ask once per session (or when the user requests deeper research):
+
+“Do you want deep research for these leads (parallel sonnet subagents)? Yes/No”
+
+If **Yes**:
+
+- Call `get_subskill_prompt({ subskillName: "research-prospect" })`
+- For each lead, run the **Shared Flow** with `positioningMode=false`
+- Use LinkedIn URL + company name when available
+- If a Company LinkedIn URL exists in row data, pass it as `companyLinkedinUrl`
+- Synthesize findings into a short “Research Notes” block per lead
+
+If **No**: proceed directly to drafting.
+
+### 2) Single Lead (in-thread)
+
+1. Call `get_rows({ tableId, rowIds: selectedRowId })`.
+2. Use `craftPrompt` as the authoritative craft rules (includes research subtask).
+3. Call `get_message_prompt()`.
+4. Craft message using the REPLY framework.
+5. Show message + gates summary.
+6. If the message cell is empty, **auto-save the draft** with `update_cell(messageCellId, message)` and say “Draft saved (not approved).”
+7. If the message cell already has content, ask before overwriting. Only save on explicit user confirmation.
+8. Ask if they want to approve for sending; if yes: `update_cell(approveCellId, true)`.
+
+### 3) Batch (parallel)
+
+If user selects multiple leads:
+
+1. Call `get_message_prompt()` once.
+2. Spawn parallel Task subagents for each row **with explicit `model: "opus"` and `subagent_type: "general-purpose"`** (never omit model):
+   - Provide campaign brief + positioning + sender info
+   - Include the full REPLY framework from `get_message_prompt()`
+   - Provide row data + messageCellId + tableId
+   - Use WebSearch + LinkedIn tools only if needed
+   - **Do NOT** save in subagent; return draft + research notes only
+3. Wait for all tasks.
+4. For rows where the message cell is empty, auto-save drafts with `update_cell` and announce “Draft saved (not approved).”
+5. Summarize drafts and ask which to overwrite or edit.
+6. Save selected drafts with `update_cell`.
+7. Ask whether to approve saved messages.
+
+### Selection Logic
+
+- If the user selects one row: run the single-lead flow.
+- If the user selects multiple rows: run the batch flow.
+
+### Optional: Research Subtask (if user requests deeper research)
+
+Use `research-prospect` (wrapper over `mcp/sellable/skills/research/SKILL.md`) and run the Shared Flow with `positioningMode=false`. Only run this when explicitly asked to deepen research.
+
+## Approval Rules
+
+- Never auto-approve a message.
+- Auto-save drafts is allowed **only** when the message cell is empty.
+- Do not overwrite a non-empty message without explicit user approval.
+- After saving, always ask whether to approve the message for sending.

package/skills/campaign-messages/flow.v1.json

@@ -0,0 +1,75 @@
+{
+  "version": "v1",
+  "workflow": "campaign-messages",
+  "principle": "Preview  Select  Draft  Save  Approve",
+  "events": [
+    "leads_selected",
+    "drafts_ready",
+    "messages_saved",
+    "approval_complete"
+  ],
+  "steps": [
+    {
+      "id": "load-preview",
+      "label": "Load Campaign + Preview",
+      "allowedTools": [
+        "get_auth_status",
+        "get_campaign",
+        "get_campaign_messages_preview",
+        "get_table_rows",
+        "AskUserQuestion"
+      ],
+      "waitFor": "leads_selected",
+      "transitions": {
+        "leads_selected": "draft-messages"
+      }
+    },
+    {
+      "id": "draft-messages",
+      "label": "Draft Messages",
+      "allowedTools": [
+        "get_rows",
+        "get_message_prompt",
+        "get_subskill_prompt",
+        "WebSearch",
+        "fetch_linkedin_profile",
+        "fetch_linkedin_posts",
+        "fetch_company",
+        "Task"
+      ],
+      "waitFor": "drafts_ready",
+      "transitions": {
+        "drafts_ready": "save-messages"
+      }
+    },
+    {
+      "id": "save-messages",
+      "label": "Save Messages",
+      "allowedTools": [
+        "update_cell",
+        "AskUserQuestion"
+      ],
+      "waitFor": "messages_saved",
+      "transitions": {
+        "messages_saved": "approve-messages"
+      }
+    },
+    {
+      "id": "approve-messages",
+      "label": "Approve Messages",
+      "allowedTools": [
+        "update_cell",
+        "AskUserQuestion"
+      ],
+      "waitFor": "approval_complete",
+      "transitions": {
+        "approval_complete": "done"
+      }
+    },
+    {
+      "id": "done",
+      "label": "Done",
+      "terminal": true
+    }
+  ]
+}

package/skills/craft-message/SKILL.md

@@ -0,0 +1,401 @@
+---
+name: craft-message
+description: Craft a deeply researched, personalized LinkedIn message by exploring 10 angles in parallel and combining the best elements — like Doctor Strange viewing 14 million futures to find the one that wins. 5+ minutes of compute per message. The kind of message that gets replies.
+model: opus
+visibility: internal
+---
+
+# Craft Message
+
+You craft personalized LinkedIn outreach messages that are indistinguishable from hand-written ones. Every message gets 5+ minutes of compute across **3 parallel phases**: 6-agent research, 10-agent angle exploration, then Opus finalizer synthesis. Like Doctor Strange viewing 14 million futures — explore every angle in parallel, then combine the winning elements into one message. This is the "manufactured thoughtfulness" that gets 20%+ reply rates.
+
+## Progress Narration (CRITICAL)
+
+**NEVER use silent thinking.** Always narrate your progress visibly so users know what's happening:
+
+```
+> Loading prospect data + configs + REPLY framework (parallel)...
+> Launching 6 research agents (posts, homepage, LinkedIn, role, growth, reviews)...
+> Research complete. Synthesizing findings...
+> Launching 10 angle agents in parallel...
+> 10 drafts received. Analyzing angles...
+> Best opener: post-hook (referenced their "scaling culture" post)
+> Best bridge: story-mirror (both bootstrapped before raising)
+> Best credibility: micro-observation (noticed their comment on a niche thread)
+> Combining + voice-checking + credibility pass... Final gates: 12/12
+```
+
+Share findings as you go - don't wait until the end. Users should see your reasoning in real-time.
+
+## Architecture
+
+```
+Phase 1: Bootstrap        6 parallel loads (data + configs + framework)         ~2s
+Phase 2: Research          6 parallel Sonnet agents (one message, no background) ~15s
+Phase 2.5: Condense        Build ~1.5k token angle brief from full context       ~1s
+Phase 3: Angle Fan-Out    10 parallel Sonnet agents (~2k tokens each = ~20k)    ~15s
+Phase 4: Finalizer         Opus combines best of 10 + credibility + full gates   ~30s
+Phase 5: Show + Save       Present final message for approval
+```
+
+**Context budget:** Angle agents get condensed briefs (~2k tokens each × 10 = ~20k total). The Opus finalizer holds the full REPLY framework (~11k), full configs, and full research. This keeps total context well under limits.
+
+## CRITICAL: No `run_in_background` for Task Agents
+
+**DO NOT use `run_in_background: true`** when launching research or angle agents. Background agents send completion notifications as separate conversation turns AFTER you've moved to later phases, causing notification spam (the model re-asks the approval question 10+ times).
+
+**Instead:** Launch all agents in a **single message** as regular Task calls (no `run_in_background`). Multiple Task calls in one message execute concurrently. All results return together when the last agent finishes. Zero delayed notifications.
+
+```
+✅ CORRECT: 10 Task calls in ONE message (no run_in_background) → all run in parallel, results arrive together
+❌ WRONG:  10 Task calls with run_in_background: true → notification spam after final message shown
+❌ WRONG:  10 Task calls sequentially (one per message) → 10x slower, defeats the purpose
+```
+
+## Source of Truth
+
+The REPLY framework prompt is loaded via `get_message_prompt()`. This returns the full methodology including:
+
+- 10-step workflow (research -> hooks -> gates -> polish)
+- 11 quality gates with detailed pass/fail criteria
+- Anti-patterns to avoid
+- Formatting rules
+
+**Angle agents get a condensed brief** for creative exploration. **Only the Opus finalizer uses the full framework** for compliance and gate-checking. This separation is what makes 10 parallel agents feasible without blowing context.
+
+## Available Tools
+
+Row/Cell tools (free):
+
+- `mcp__sellable__get_rows` - Get full row data for crafting
+- `mcp__sellable__update_cell` - Save message or approve for sending
+- `mcp__sellable__get_message_prompt` - Load the REPLY framework prompt
+- `mcp__sellable__get_subskill_prompt` - Load shared research protocol
+
+Parallel execution:
+
+- `Task` - Spawn parallel subagents (research agents, angle agents)
+
+Config tools (built-in, free):
+
+- `Read` - Load voice configs, outbound rules, and cross-skill insights from `.sellable/`
+
+Research tools (free - user's Claude tokens):
+
+- `WebSearch` - Search web for prospect news, posts, company info
+
+LinkedIn tools (cost credits):
+
+- `mcp__sellable__fetch_linkedin_posts` - Get prospect's recent LinkedIn posts
+- `mcp__sellable__fetch_linkedin_profile` - Get full profile details
+- `mcp__sellable__fetch_company` - Get company profile details
+
+## Input
+
+You receive from the campaign flow (or user provides):
+
+- Campaign: brief, positioning, dos/donts
+- Sender: name, company, background, proof points
+- Lead: rowId, name, company, title, linkedinUrl
+- tableId: for API calls
+- cellIds: messageCellId, approveCellId
+
+## Workflow
+
+### Step 1: Parallel Bootstrap (single message — all independent)
+
+**Batch ALL of these calls in one message — they have zero dependencies on each other:**
+
+```
+Parallel batch (6 calls):
+├── get_rows(rowId)                                    → prospect data
+├── get_message_prompt()                               → REPLY framework
+├── get_subskill_prompt({ subskillName: "research-prospect" })  → research protocol
+├── Read .sellable/configs/writing/outbound.md         → outbound rules
+├── Read .sellable/configs/writing/styleguide-core.md  → sender voice
+└── Read .sellable/insights/cross-skill.md             → cross-skill learnings
+```
+
+If any config file doesn't exist yet, skip silently. After all return:
+
+1. Extract `linkedinUrl` from row data (cells/fields like `linkedinUrl`, `LinkedIn URL`, `linkedin`, `linkedin_url`)
+2. Extract `companyLinkedinUrl` if present (cells/fields like `Company LinkedIn URL`, `LinkedIn Company URL`, `companyLinkedinUrl`)
+3. Store configs for voice calibration in Step 3
+
+### Step 2: Parallel Research (6 Sonnet agents in one message)
+
+Follow the research protocol from Step 1. Set `positioningMode=false`.
+
+**Launch ALL 6 Sonnet agents in a SINGLE message** (no `run_in_background`):
+
+```
+One message with 6 Task calls (all run concurrently):
+├── Agent 1: Post Analyzer         (fetch_linkedin_posts)
+├── Agent 2: Homepage Snapshot     (WebFetch)
+├── Agent 3: Company LinkedIn      (WebSearch + fetch_company)
+├── Agent 4: Role Context          (no tools — pure reasoning)
+├── Agent 5: Jobs + Funding        (WebSearch)
+└── Agent 6: Reviews + Traffic     (WebSearch)
+```
+
+All 6 results return together when the last agent finishes. Then synthesize into a Research Notes block.
+
+- Use WebSearch only by default. If you need LinkedIn tools (credits), ask first.
+
+### Step 2.5: Build Condensed Angle Brief (CRITICAL for context management)
+
+**WHY THIS STEP EXISTS:** The full REPLY framework is ~11k tokens. Passing it to each of 10 angle agents would consume ~110k tokens of parent context just in tool call prompts — causing context overflow. Instead, the orchestrator extracts a condensed brief (~1.5k tokens) that angle agents use for creative exploration. The Opus finalizer handles full REPLY compliance in Step 4.
+
+Extract the following from the REPLY framework, configs, and research into a single condensed string:
+
+```
+## Angle Brief (pass this to every angle agent — ~1.5k tokens max)
+
+### Prospect
+- Name: {name} | Title: {title} | Company: {company}
+- Top of Mind: {1-2 lines from research synthesis}
+- Key Hooks: {3-4 bullet points from research — post topics, company news, pain points}
+
+### Sender
+- Name: {sender name} | Company: {sender company}
+- Core thesis: {1 line from styleguide-core.md}
+- Signature phrases: {3-5 key phrases from styleguide-core.md}
+- Offer: {1 line from campaign brief}
+
+### Message Rules
+- Structure: observation about THEM → why it's relevant → soft ask
+- Under 300 characters for the opener. Under 900 characters total.
+- No bullet points. No "I noticed..." or "I saw...". No compliment sandwiches.
+- Sound like a human peer, not a salesperson. Use sender's natural voice.
+- Must include one specific detail that proves you did your homework.
+
+### Campaign Context
+- {2-3 line summary of brief, positioning, dos/donts}
+
+### Cross-Skill Insights
+- {2-3 bullets from cross-skill.md — what angles/hooks have worked}
+```
+
+**DO NOT include the full REPLY framework, full styleguide, or full outbound.md in the angle brief.** Keep it under 1,500 tokens. The finalizer has all the full documents.
+
+### Step 3: Angle Exploration — Fan-Out (10 parallel agents)
+
+This is the Doctor Strange step. Instead of drafting one message linearly, **fan out 10 parallel agents** — each exploring a completely different angle. More angles explored = better final message. Every agent gets the condensed angle brief + their specific angle instruction.
+
+**Launch ALL 10 in a SINGLE message** (no `run_in_background`):
+
+```
+One message with 10 Task calls (all run concurrently):
+├── Agent A:  Post-Hook           → opens with something specific they said/posted
+├── Agent B:  Company-Momentum    → opens with their company's growth signal
+├── Agent C:  Pain-Point          → leads with a role-specific challenge they face
+├── Agent D:  Shared-World        → finds common ground between sender + prospect
+├── Agent E:  Contrarian          → unexpected take that reframes their problem
+├── Agent F:  Trigger-Event       → hooks on something that just happened (job change, launch, milestone)
+├── Agent G:  Value-First         → leads with a specific insight or resource before asking
+├── Agent H:  Micro-Observation   → hyper-specific detail from their profile/content
+├── Agent I:  Story-Mirror        → mirrors prospect's journey with sender's journey
+└── Agent J:  Industry-Trend      → connects to a macro trend reshaping their space
+```
+
+**CRITICAL:** Do NOT use `run_in_background: true` for angle agents. Launch all 10 as regular Task calls in ONE message — they execute concurrently and all results return together. Using `run_in_background` causes completion notifications to arrive after the final message is shown, triggering notification spam.
+
+#### Agent Prompt Template (~2k tokens per agent, NOT 15k)
+
+```
+Draft ONE LinkedIn message from the {angle_name} angle.
+
+## Your Angle
+{angle_name}: {angle_description}
+
+## Brief
+{condensed angle brief from Step 2.5 — ~1.5k tokens}
+
+## Instructions
+1. Find the strongest bridge between your angle and the prospect's world
+2. Draft a complete message: observation about THEM → relevance → soft ask
+3. Use the sender's signature phrases naturally
+4. Keep under 900 chars total, opener under 300 chars
+5. Return EXACTLY:
+---
+ANGLE: {angle name}
+RATIONALE: {1 line — why this angle wins}
+MESSAGE:
+{the message}
+---
+```
+
+**IMPORTANT: Each agent prompt must be ~2k tokens max.** This is what makes 10 agents feasible — 10 × 2k = 20k tokens vs 10 × 15k = 150k (which blows context). The finalizer does full gate-checking, not the angle agents.
+
+#### Angle Definitions
+
+| Agent | Angle                 | Description                                                                                                             |
+| ----- | --------------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| A     | **Post-Hook**         | Opens with something specific the prospect said or posted. Uses a direct quote, topic, or reaction. Most personal.      |
+| B     | **Company-Momentum**  | Opens with a growth signal — funding, hiring, product launch, press. Shows you pay attention to their company.          |
+| C     | **Pain-Point**        | Leads with a challenge specific to their role/title. Demonstrates you understand what keeps them up at night.           |
+| D     | **Shared-World**      | Finds common ground — shared background, mutual interest, industry overlap, similar journey. Peer connection.           |
+| E     | **Contrarian**        | Unexpected angle — challenges a common assumption, reframes their problem, pattern-interrupt.                           |
+| F     | **Trigger-Event**     | Hooks on something that just happened — job change, promotion, product launch, company milestone. Time-sensitive.       |
+| G     | **Value-First**       | Leads with a specific insight, observation, or resource that gives value before asking for anything.                    |
+| H     | **Micro-Observation** | Hyper-specific detail from their profile, a comment they left, a niche bio detail. Shows obsessive attention to detail. |
+| I     | **Story-Mirror**      | Mirrors the prospect's journey with the sender's journey — "I went through X too." Builds empathy.                      |
+| J     | **Industry-Trend**    | Connects to a macro trend reshaping their space and positions the sender's offer as relevant to it.                     |
+
+**Use `model: "sonnet"` and `subagent_type: "general-purpose"` for all 10 angle agents.** Sonnet is fast enough for drafting; Opus handles the final synthesis and full REPLY gate-check.
+
+**Narrate when launching and when results arrive:**
+
+```
+> Launching 10 angle agents in parallel...
+> [all 10 results arrive together]
+> 10/10 angles explored. Analyzing drafts...
+```
+
+### Step 4: Finalizer — Combine + Credibility + Full REPLY Gate-Check (Orchestrator)
+
+After all 10 angle agents return, **you (the Opus orchestrator) act as the finalizer.** You have the full REPLY framework, full configs, and full research in your context — the angle agents had condensed briefs, but YOU have everything. This is where compliance, credibility, and quality all converge.
+
+**Finalizer process:**
+
+1. **Read all 10 drafts** — lay them out side by side (internally)
+2. **Score each angle:**
+   - Which opener is most arresting? (pattern-interrupt value)
+   - Which bridge is most natural? (doesn't feel forced)
+   - Which body flows best? (observation → relevance → ask)
+   - Which CTA is most compelling? (low-friction, high-curiosity)
+3. **Combine the winning elements** — the best opener from one, the best bridge from another, the best CTA from a third. You're not picking a winner — you're assembling a new message from the best parts across all 10.
+4. **Credibility pass (CRITICAL)** — the message must build credibility, not just be pleasant:
+   - Does it demonstrate that the sender actually understands the prospect's world? Not generic flattery — specific, earned insight.
+   - Does it say something the prospect hasn't heard from 50 other salespeople? If the opener could apply to anyone in their role, it's too generic. Rewrite.
+   - Does the bridge prove the sender has a unique perspective? The message should make the prospect think "this person actually gets it" — not "this person read my LinkedIn headline."
+   - Is there at least one sentence that would make the prospect stop scrolling? Something surprising, specific, or contrarian.
+   - Kill any line that reads like a template. If you've seen it in a cold outreach before, rewrite it.
+5. **Voice-check** — does it sound like the sender? Use their signature phrases from `styleguide-core.md` (the FULL file, not the condensed brief).
+6. **Full 12-gate check using the REPLY framework** — this is the only place the full framework is applied. All gates must pass on the combined message. The angle agents drafted creatively; you enforce compliance.
+7. **Polish** — one final pass for flow, tone, and length
+
+If the combined message fails any gates or the credibility pass, iterate until it passes. The finalizer has unlimited iterations — never show a message that fails.
+
+**Progress narration during finalizer:**
+
+```
+> 10 angles explored. Analyzing drafts...
+> Best opener: Agent A (post-hook — referenced their "scaling culture" post)
+> Best bridge: Agent I (story-mirror — both bootstrapped before raising)
+> Best credibility: Agent H (micro-observation — noticed their comment on a niche thread)
+> Best CTA: Agent C (pain-point — asked about their hiring bottleneck)
+> Combining elements + credibility pass + voice-check...
+> Final gate check: 12/12 passed
+```
+
+### Step 5: Show for Approval
+
+After the message passes all 12 gates + credibility pass, show the user the message ONCE with a concise "Why this works" section. The format builds trust through explainability without being verbose. Show the message prominently, then prove it's not generic.
+
+```
+**Message for {name} @ {company}:**
+
+{newMessage}
+
+**Why this works:**
+  ✓ Opener: {angle name} — {specific signal used, e.g. "role shift + 20% marketplace data"}
+  ✓ Bridge: {angle name} — {why it's not generic, e.g. "reframes seller acquisition as quality problem"}
+  ✓ Scroll-stopper: "{exact quote from message that would make them stop scrolling}"
+  ✓ Template check: 0 generic phrases found
+
+Gates: 12/12 | Angles explored: 10
+```
+
+**Rules for this section:**
+
+- Show the message exactly ONCE — never repeat it
+- "Why this works" is 4 lines max — one for opener, bridge, scroll-stopper, and template check
+- The scroll-stopper is the single most compelling line from the message — quote it exactly
+- Don't show the full scoring table or all 10 angle breakdowns — just the winners
+- Don't show the credibility pass checklist inline — it's internal. The "Why this works" section IS the user-facing credibility proof
+
+If the current message is empty, auto-save the draft after showing it and say "Draft saved (not approved)."
+If the current message already has content, ask before overwriting:
+
+- Yes, save it
+- Let me tweak it first
+- Try again with different approach
+
+CRITICAL: Never auto-approve. Only auto-save when the message cell is empty.
+
+### Step 6: Save Draft
+
+If the message cell is empty, auto-save immediately after showing the draft:
+
+```
+update_cell(messageCellId, newMessage)
+```
+
+If the message cell already has content, only save after the user confirms "save it":
+
+```
+update_cell(messageCellId, newMessage)
+```
+
+Then IMMEDIATELY show:
+
+```
+Message saved!
+
+---
+
+**Ready to approve for sending?**
+
+Approved messages will be sent by the Sellable sweeper at scheduled times.
+
+- **Yes, approve it** — mark ready to send
+- **Not yet** — review in Sellable first
+```
+
+CRITICAL: Always ask this question after saving. Never auto-approve.
+
+### Step 7: Mark Approved (only if user confirms)
+
+If user says yes/approve:
+
+```
+update_cell(approveCellId, true)
+```
+
+Then confirm:
+
+```
+Approved! Message queued for sending.
+```
+
+### Step 8: Return to Campaign Flow
+
+After saving (and optionally approving), return control for:
+
+- Crafting another message
+- Viewing updated stats
+- Campaign controls
+
+## Critical Rules
+
+1. **Load configs first** — read `.sellable/configs/writing/outbound.md` and `styleguide-core.md` before crafting. The message must sound like the sender.
+2. **Load the framework first** — always call `get_message_prompt()` before crafting
+3. **Always fan out 10 angles** — never skip the angle exploration step. More angles = better final message. This is the core differentiator.
+4. **Launch agents in ONE message, no `run_in_background`** — all 10 angle agents (and all 6 research agents) must be launched as regular Task calls in a single message. They run concurrently and all results return together. Never use `run_in_background: true` — it causes notification spam.
+5. **Finalizer combines, doesn't pick** — don't just select the "best" draft. Extract the best opener from one, best bridge from another, best CTA from a third. The final message should be better than any individual draft.
+6. **Credibility pass is mandatory** — the finalizer must verify the message says something the prospect hasn't heard from 50 other people. Generic flattery fails the pass. If it could apply to anyone with their title, rewrite it.
+7. Never auto-approve a message
+8. Auto-save drafts is allowed only when the message cell is empty
+9. Do not overwrite a non-empty message without explicit user approval
+10. All 12 gates must pass — iterate until they do
+11. **Research deeply** — this is the value (5+ min per message). Compute time is the quality knob.
+12. Credits awareness — note when using LinkedIn tools
+13. **Use cross-skill insights** — if `insights/cross-skill.md` shows what hooks/angles resonate, use those patterns in the angle exploration
+
+## Developer Note
+
+The REPLY framework prompt is maintained at:
+`src/config/outbound-builder/steps/editMessage/prompt.ts`
+
+Edits there apply to both the web app and Claude Code plugin.