@sellable/mcp 0.1.951-wip.sendercontext.20261001.1 → 0.1.952

package/dist/tools/bootstrap.d.ts

@@ -1,8 +1,8 @@
 import { type AuthStatus } from "./auth.js";
 import { getCampaignContext } from "./context.js";
 import { getCampaignFramework } from "./framework.js";
-import { type ListSubskillPromptsResponse, type SubskillPromptResponse } from "./prompts.js";
 import { type CampaignModelQualityResult } from "./model-quality.js";
+import { type ListSubskillPromptsResponse, type SubskillPromptResponse } from "./prompts.js";
 type BootstrapCreateCampaignInput = {
     campaignId?: string;
     flowVersion?: "v1" | "v2";

package/dist/tools/bootstrap.js

@@ -2,8 +2,8 @@ import { resetApi } from "../api.js";
 import { getAuthStatus } from "./auth.js";
 import { getCampaignContext } from "./context.js";
 import { getCampaignFramework } from "./framework.js";
-import { getSubskillPrompt, listSubskillPrompts, } from "./prompts.js";
 import { evaluateCampaignModelQuality, getCampaignModelMinimumSummary, } from "./model-quality.js";
+import { getSubskillPrompt, listSubskillPrompts, } from "./prompts.js";
 function toErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -307,7 +307,7 @@ export async function bootstrapCreateCampaign(input = {}) {
         ? resumeDetected
             ? `Bootstrap complete.${workspaceNotice}${modelNotice} Resume from campaign state and navigation diagnostics first; treat local draft artifacts as debug-only evidence. Then load ${createCampaignSubskill?.name ?? "create-campaign"} instructions with get_subskill_prompt({ subskillName: "${createCampaignSubskill?.name ?? "create-campaign"}" }); if the response has hasMore=true, continue with nextOffset until hasMore=false.`
             : flowVersion === "v2"
-                ? `Bootstrap complete.${workspaceNotice}${modelNotice} Load the compact create-campaign-v2 entry prompt once with get_subskill_prompt({ subskillName: "create-campaign-v2" }); Hermes users should start this flow with /sellable-create-campaign. Load flow/reference assets lazily only when that stage needs them. Preserve the pre-intake sequence: confirm auth/workspace status, ask only for the LinkedIn profile URL or handle, normalize handles to a full profile URL, require that profile identity before continuing, run lightweight profile/company lookup, then ask the target, offer, credibility, and prospect-source setup questions. Do not call list_senders or sender discovery during setup; sender availability belongs only to Settings after message approval. Then write the campaign brief, call create_campaign once to mint the watchable shell, surface the returned watch link once before brief approval, and hand off to lead finding without repeating the link.`
+                ? `Bootstrap complete.${workspaceNotice}${modelNotice} Load the compact create-campaign-v2 entry prompt once with get_subskill_prompt({ subskillName: "create-campaign-v2" }); Hermes users should start this flow with /sellable-create-campaign. Load flow/reference assets lazily only when that stage needs them. Preserve the pre-intake sequence: confirm auth/workspace status, ask only for the LinkedIn profile URL or handle, normalize handles to a full profile URL, require that profile identity before continuing, run lightweight profile/company lookup, then ask the target, offer, credibility, and prospect-source setup questions. Do not call list_senders or sender discovery during setup; sender availability belongs only to Settings after message approval. Then write the campaign brief, call create_campaign once to mint the watchable shell, surface the returned watch link once before brief approval, and hand off to lead finding without repeating the link. Exception: when you entered from the first-campaign-onboarding skill, its first-campaign rules replace the workspace notice, the slash-command note, the setup questions, and the watch-link handoff described here.`
                 : `Bootstrap complete.${workspaceNotice}${modelNotice} Load ${createCampaignSubskill?.name ?? "create-campaign"} instructions with get_subskill_prompt({ subskillName: "${createCampaignSubskill?.name ?? "create-campaign"}" }); if the response has hasMore=true, continue with nextOffset until hasMore=false. Follow that flow before calling create_campaign.`
         : "Bootstrap incomplete. Resolve blockingErrors and rerun bootstrap_create_campaign before provider/search/import tools.";
     // Strip prompt body from createCampaignSubskill — it's loaded via the host

package/dist/tools/campaigns.d.ts

@@ -619,6 +619,7 @@ export declare const campaignToolDefinitions: ({
                     };
                     safety: {
                         type: string[];
+                        description: string;
                     };
                     progressLabel: {
                         type: string[];
@@ -859,6 +860,7 @@ export declare const campaignToolDefinitions: ({
                     };
                     safety: {
                         type: string[];
+                        description: string;
                     };
                     progressLabel: {
                         type: string[];

package/dist/tools/campaigns.js

@@ -29,7 +29,10 @@ const WATCH_NARRATION_TOOL_SCHEMA = {
         visibleState: { type: "string" },
         agentIntent: { type: "string" },
         nextAction: { type: ["string", "null"] },
-        safety: { type: ["string", "null"] },
+        safety: {
+            type: ["string", "null"],
+            description: 'Required whenever currentStep changes: one short line on what will not happen yet (for example "Rules only. No one is contacted."). Optional otherwise.',
+        },
         progressLabel: { type: ["string", "null"] },
         blockedReason: { type: ["string", "null"] },
         workerStatuses: {

package/dist/tools/registry.d.ts

@@ -2702,6 +2702,7 @@ export declare const allTools: ({
                     };
                     safety: {
                         type: string[];
+                        description: string;
                     };
                     progressLabel: {
                         type: string[];
@@ -2942,6 +2943,7 @@ export declare const allTools: ({
                     };
                     safety: {
                         type: string[];
+                        description: string;
                     };
                     progressLabel: {
                         type: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/mcp",
-  "version": "0.1.951-wip.sendercontext.20261001.1",
+  "version": "0.1.952",
   "type": "module",
   "description": "Sellable MCP server for Claude Code, Codex, and Hermes campaign workflows",
   "main": "dist/index.js",

package/skills/create-campaign/references/ai-native-tokens.md

@@ -53,6 +53,13 @@ The bracket is replaced at generation time by either (a) the rendered
 sentence, or (b) nothing (omit). The brackets themselves never appear in
 the final message.
 
+**When you save the template in the campaign brief, write each bracket on one
+line.** The examples below wrap a bracket across lines so it is readable here.
+The brief validator reads a bracket that spans three or more lines as message
+prose and rejects the save ("3+ consecutive non-empty prose lines with only
+single newlines"). Keep the DO / DON'T / FALLBACK labels; drop the line breaks
+inside the bracket.
+
 ## Required clauses inside an AI-native token
 
 Every well-specified AI-native token must include four things:

package/skills/create-campaign-v2/core/policy.md

@@ -90,5 +90,8 @@ messages that pass my quality check and launch for you, then keep your sends fil
 Reply review first if you would rather approve." Save the answer with `customer_program`
 `save_context` as `launchConsent: { mode: "autopilot" | "review_first", decidedAt }`.
 A yes, or no objection, is `autopilot`; a wish to approve first is `review_first`.
-Never ask again; a later "review first" switches to `review_first`, and "pause" sets the saved work and sending pauses with `set_preferences`. If the
+A reply that answers other questions and says nothing about this offer is not an answer to it:
+save nothing and keep every approval. Never ask again; a later "review first" switches to `review_first`, and "pause" sets the saved work and sending pauses with `set_preferences`. If the
 customer has not answered when you reach launch, keep the launch confirmation.
+During a new workspace's first campaign (`first-campaign-onboarding`) do not make this offer at all:
+the first launch always needs the customer's explicit yes.

package/skills/create-campaign-v2/references/watch-guide-narration.md

@@ -40,7 +40,8 @@ states.
   sample you are checking, and why that helps this campaign.
 - At filter choice, do not say the batch is filtering before rubrics are saved.
 - Avoid internal terms: MCP, tool, currentStep, workflow table, scout, debug.
-- Treat `safety` as optional internal context, not a visible disclaimer.
+- Always send a short `safety` line when the step changes; the API rejects a
+  step change without one. It is internal context, not a visible disclaimer.
 - Do not repeat long negative lists like "no leads import, no enrichment, no
   messages, no sequence, no sending" in routine watch copy. Prefer one concise
   gate phrase only when it matters: "This only approves me to look for the best

package/skills/create-campaign-v2-tail/SKILL.md

@@ -198,9 +198,8 @@ import milestone.
    `messaging.critique.enabled`, `handoff.autoStart`,
    `handoff.orientation`, `retry.sameToolSameError`,
    `logging.logEveryThresholdTrip`.
-2. Resolve and materialize the approved source after Start Import approval. Load
-   `references/post-mint-source-materialization.md` when the source is normal
-   discovery or when a legacy no-shell approval fixture must be replayed. If
+2. Resolve and materialize the approved source after Start Import approval.
+   `references/step-13-import-leads.md` holds the import steps. If
    CampaignOffer state already attached searches/selections to this campaign,
    reuse them. If there is no `lead-source-intake.json`, replay the approved
    provider recipe from `lead-review.md` with `campaignOfferId` before
@@ -622,7 +621,6 @@ runs.
 | ------------------------------------------------ | ------------------------------------------------------------------------- |
 | `references/approval-gate-framing.md`            | Approval gate, before showing the approval packet                         |
 | `references/watch-link-handoff.md`               | First brief handoff + explicit link recovery only                         |
-| `references/post-mint-source-materialization.md` | Step 13, before importing normal-discovery or legacy campaignless sources |
 | `references/sample-validation-loop.md`           | Step 14, before enriching + scoring the sample                            |
 | `references/escalation-ladder.md`                | Any tail step that needs to decide retry / revise / escalate              |
 | `references/final-handoff-contract.md`           | Step 16, and every Claude greenlight turn                                 |

package/skills/first-campaign-onboarding/SKILL.md

@@ -48,11 +48,14 @@ reply to either the same way.)
 A reply in that thread is explicit permission to begin preparation, not
 permission to send. It needs no mention of this Agent.
 
-- **The reply contains a LinkedIn profile URL.** Before any tool call, send
-  one short line so the customer is not left looking at silence: "Got it.
-  Researching you and your company now. I'll be back in a couple of minutes
-  with a first campaign to review." Then enter **Create-Campaign Handoff** in
-  the same turn, with that URL as the sender identity.
+- **The reply contains a LinkedIn profile URL.** Send one short line first so
+  the customer is not left looking at silence: "Got it. Researching you and
+  your company now. I'll be back in a few minutes with a first campaign to
+  review." Send it before the Live State Check and before loading any other
+  skill or reference; those reads take over a minute. Then run the Live State
+  Check and enter **Create-Campaign Handoff** in the same turn, with that URL
+  as the sender identity. If the Live State Check finds a campaign already
+  launched, say so in the next line and offer to help with that campaign.
 - **The reply is a yes, or anything else that agrees, with no profile URL.**
   Ask for it once, in one sentence: "What's your LinkedIn profile URL? I'll
   use it to research you and your company." Ask nothing else.
@@ -209,18 +212,220 @@ continue in the same conversation; do not ask the user to run another command.
 
 1. Call `bootstrap_create_campaign({ flowVersion:"v2", host:<current host> })`.
 2. Load `get_subskill_prompt({ subskillName:"create-campaign-v2" })` to
-   `hasMore:false` and load every required asset it names.
+   `hasMore:false`, then `core/flow.v2.json`. Load every other reference only
+   at the stage that needs it. The customer is waiting in silence, so make
+   these reads in as few turns as you can: the Live State Check reads together
+   in one turn; then bootstrap, the create-campaign-v2 prompt, the flow file,
+   `research-sender` and `list_dnc_entries({ limit:1 })` together in the next.
 3. Reuse known identity, company, audience, offer, and any explicit DNC decision.
-   Ask only missing intake in the canonical flow. A public LinkedIn profile URL
-   for company research is not a connected sending account: the latter belongs
-   at Settings, not before the draft. Preserve the normal brief/watch, source,
-   filter, message, sender, sequence, and approval gates. Offer CRM or meeting
-   integrations only as optional context when helpful.
+   A public LinkedIn profile URL for company research is not a connected
+   sending account: the latter belongs at Settings, not before the draft.
+   The flow's order and state gates still hold: the campaign exists before
+   anyone is imported, the source is chosen before the import, sample rows
+   exist before filters and messages run, and the template is saved before
+   anything is queued. Who decides each one is set by the next section. Offer
+   CRM or meeting integrations only as optional context when helpful.
 4. Reuse an existing draft for the same goal. Never create a duplicate because
    onboarding resumed in a new session.
 5. Agreement authorizes campaign creation/preparation only, not launch. Never
-   call `start_campaign` until the create-campaign workflow presents its final
-   launch packet and the user explicitly approves Start.
+   call `start_campaign` until the customer has seen who sends and how many a
+   day, and explicitly says to launch.
+
+### The first campaign in three approvals
+
+The welcome promised "a first campaign for you to review". For a new
+workspace's first campaign the customer is asked for three things and nothing
+else: the **direction**, the **sample**, and the **launch**. You decide
+everything in between yourself, using the flow's own hands-off rules
+(`yoloMode.autoSelectsPreLaunchChoices`, except its "brief approval" and
+"generated message review" entries, which are approvals 1 and 2 here), and say
+what you chose in one plain line when you report back. Where the general workflow, a reference file, or a
+tool result says otherwise, this section wins for the first campaign.
+
+This is not the standing `launchConsent` autopilot. Do not ask about or save
+`launchConsent` during the first campaign, and never skip one of the three
+approvals. Silence, or a reply that answers something else, is never an
+approval. The daily review offers hands-off sending once the first campaign is
+running.
+
+**What you never ask.** Not the four setup questions ("Who should we target
+first?", "What should we pitch?", the credibility question, "How should we
+find prospects?"): giving the profile URL is the customer's instruction to use
+Sellable's researched recommendation and to find prospects for them, which is
+the flow's own skip rule for each question. Not "is this the right company?"
+or "which of your offers should I lead with?": pick the one the profile and
+site lead with and say so in the direction, where they can correct it. Not a
+separate approval for where
+to look, for starting the import, for using filters, for the filter rules, or
+for the message template: those are yours to decide and report.
+
+**How you write in Slack.**
+
+- Ask in plain words the customer can answer with yes or with the change they
+  want. Slack has no question panel: never ask for option letters, and never
+  mention a question panel or a config file.
+- Post nothing between "Got it" and the direction: no research progress lines,
+  tool names, counts of proof items, or which workspace you are in (this Agent
+  is locked to one workspace and the customer knows which).
+- Never print the "WATCH … BUILD THE CAMPAIGN LIVE" block, "Keep this chat
+  open", "Brief approved", or any line that tells the customer to run a
+  command. Those are written for other hosts.
+- The channel is shared, and the returned `watchUrl` carries a sign-in token.
+  Post that URL with only its `token` parameter removed, keeping the rest
+  exactly as returned. The customer signed in to Sellable when they set this
+  Agent up. This replaces the tool's instruction to print the handoff block
+  and its rule against changing the link.
+- Do not paste the full brief into Slack. Save it on the campaign and post the
+  five-line summary below.
+
+**Approval 1: direction.** After research, write the brief, create the
+campaign with it (`create_campaign`), and post one message in this shape. The
+saved brief is the full brief; this message is how the customer approves it,
+so skip the flow's setup receipt, its "Does this brief look right…" question
+and the inline brief.
+
+```text
+Here's the first campaign I'd run for {company}.
+
+*Who*  {the buyer, one line}
+*Why now*  {why these people care right now, one line}
+*Offer*  {what you would get to once they reply, and the small ask, one line}
+*Proof*  {the proof you would lead with; if you found none, say so and what you would use instead}
+*Where I'll look*  {where you will find them first, in plain words}
+
+Full brief: {campaign link}
+
+Two things from you:
+1. Does this look right? Reply yes, or tell me what to change.
+2. Is there anyone I must never contact: customers, open deals, people who opted out? Paste the list here, or say "no list".
+
+Nothing is sent on LinkedIn until you approve the launch.
+```
+
+The first message to a prospect opens a conversation; the message rules
+decide its wording, and they keep the pitch and the ask out of it. So write
+the *Offer* line as what comes once the prospect replies, and do not promise,
+here or in the saved brief, that the first message will mention the post
+someone engaged with or carry the ask.
+
+If something you assumed could be stale (for example the profile pitches two
+different things), say which one you picked in the line it affects. Leave out
+the second question, and write "One thing from you:", when
+`list_dnc_entries` already shows a list or the saved program context has
+`dncState` `provided` or `explicit_none`. A yes, or "keep going", with no
+answer to the second question is not a "no list" decision, and it is not a
+reason to stop either: carry on with the list as it is, add to your
+acknowledgement "You can send me a do-not-contact list any time before
+launch.", and ask once more in the launch message. Never hold the work
+waiting for a list. Follow the DNC Contract for a pasted list, and save
+the decision with `customer_program` `save_context` (`dncState:
+"explicit_none"` for "no list", `"provided"` once a list is imported) so a
+later session does not ask again. The answer given here settles the flow's
+do-not-contact gate; do not ask again before the import.
+
+**Between 1 and 2.** Once the direction and the do-not-contact answer are in,
+reply first, before any tool call: "On it. I'll find the people, check who
+fits and write the message. Your sample will be here in about 15 to 20
+minutes." Then set `interactionMode: "autonomous"` on the campaign with
+`update_campaign` and pass `confirmed: true` where a search or import tool
+asks for it: the direction approval is that confirmation. Do the work without
+asking: pick where to look, find and import the people within the flow's
+caps, use filters and write the rules, write the message, and prepare the
+15-person sample.
+
+- **Keep the customer posted.** Whenever about five minutes have passed since
+  your last message, post one short line in plain words on where you are
+  ("Found 370 people who engaged with three posts about this. Checking who
+  fits and writing the message now."). No more often than that.
+- **The live builder.** Where the flow's required watch copy tells the
+  customer to approve something this section removed, write instead what is
+  happening and that nothing is needed from them yet.
+- **Import size.** If `import_leads` says the selected posts cover fewer
+  people than the target, select again with the number it says they cover and
+  retry once. Do not start a new search for a small gap.
+- **Waits.** A wait tool that stops with `tool_timeout_guard` has only reached
+  the host's time limit. Call it again while work is still running.
+- **A sample where nobody fits is not a pause.** Follow the flow's own
+  recovery first: a fresh sample from the same list. Stop early only for the
+  flow's must-pause reasons: missing data, or a source, filter or message
+  that still fails its quality floor after that recovery. Then say what
+  failed and what you suggest, as one question.
+- **Let the sample finish.** The flow stops at the first passing message; here
+  wait until the 15-person sample has finished scoring and writing, because
+  the customer is shown three people and a count.
+- **Check before you show.** For each message you are about to show, compare
+  the company it names with the person's own headline. Leave out any that
+  disagree and say that you dropped them.
+
+**Approval 2: sample.** When the sample is ready, post real people and the
+real message each would receive:
+
+```text
+Your sample is ready: {n} real people and the message each would get.
+
+{Name} · {title}, {company} · {why they are here, a few words}
+"{the message they would receive}"
+
+{two more like this}
+
+{passed} of {checked} people I checked fit. {one line on why the rest did not}
+What I chose: {where the people came from and how many are on the list, and the fit rules in a few words}
+The first message has no pitch on purpose. {the offer} comes once they reply.
+Everyone and every message: {campaign link}
+
+Reply approve to use these people and this message, or tell me what to change.
+Nothing has been sent.
+```
+
+**After "approve".** Reply first: "Approved." plus anything they changed, in
+the same line ("Approved, without Corey."). Mark every person in the sample
+the customer kept as approved in the table, not one or two. A person the
+customer dropped stays unapproved; never approve them later, in bulk or
+otherwise.
+
+**Approval 3: launch.** The only thing left is the sending account. Call
+`list_senders`.
+
+- **No usable sender.** Ask for that one thing: "One thing left: connect the
+  LinkedIn account that will send. https://app.sellable.dev/linkedin-accounts
+  It takes about two minutes, and it is only used to send what you approve;
+  finding and checking people happened outside your account. Tell me when
+  it's done." When they say it is done, call `list_senders` again. If nothing
+  usable is there yet, say so plainly and give the link again.
+- **One connected sender that is the person you researched.** Use it without
+  asking. If the connected account is someone else, or more than one is
+  connected, ask which account should send. That is the one extra question
+  this section allows.
+- **Get it ready, then ask.** Attach the sender and the recommended sequence
+  to the campaign yourself (`update_campaign` with `senderIds`, then
+  `attach_recommended_sequence`); this prepares the launch and sends nothing.
+  Read the real numbers for that sender (`refill_v3_world_state` for the next
+  two days). Then post:
+
+```text
+Ready to launch "{campaign name}".
+
+*Sender*  {name}
+*First sends*  {n} approved messages, {how many a day and which days, from the numbers you read}
+*Replies*  I'll post each reply here as a draft for you to approve.
+{only if no do-not-contact answer was ever given: "You haven't sent a do-not-contact list. Paste one now if there is anyone I must not message."}
+
+Reply launch to start. You can pause it any time by telling me.
+```
+
+  State only numbers you read. If you could not read one, leave that part out
+  rather than guess.
+- **Start only on an explicit yes** ("launch", "yes, start", "go"). Then call
+  `start_campaign` and report what happened: what is scheduled and for when,
+  and that scheduled is not sent yet.
+- **After the launch, one question about the rest.** Only the sample has been
+  checked and written. Ask: "{remaining} more people are on the list. Want me
+  to keep going through them and approve the messages that pass the same
+  checks, so your sends stay filled? Reply yes, or review first." Save the
+  answer as the standing `launchConsent` (`customer_program` `save_context`:
+  `autopilot` for yes, `review_first` otherwise). This is the first and only
+  time that question is asked during onboarding, and only an explicit yes is
+  `autopilot`.
 
 ## Hard Boundaries
 

package/skills/research-sender/SKILL.md

@@ -1,8 +1,8 @@
 ---
 name: research-sender
-description: "Parallel-first sender research protocol. One round of five batched tool calls (fetch_linkedin_profile + fetch_company + 3× WebSearch), no enrich_sender required, ~30-40s wall time."
+description: "Parallel-first sender research protocol. One round of five batched tool calls (fetch_linkedin_profile + fetch_company + 3× WebSearch), or the profile first and then the rest when only a profile URL is known; no enrich_sender required, ~30-40s wall time."
 visibility: internal
-allowed-tools: mcp__sellable__fetch_linkedin_profile mcp__sellable__fetch_company mcp__sellable__complete_sender_research WebSearch ToolSearch
+allowed-tools: mcp__sellable__fetch_linkedin_profile mcp__sellable__fetch_company mcp__sellable__complete_sender_research WebSearch WebFetch ToolSearch
 ---
 
 # Research Sender (Parallel-First)
@@ -64,14 +64,24 @@ Concretely, your next assistant message must contain exactly these five
 `tool_use` blocks, in any order, with no leading or trailing prose:
 
 1. `fetch_linkedin_profile({ linkedinUrl })` — sender's LinkedIn profile (firstName/lastName, currentCompany, experience, follower count, education) for the brief's "sender background" section.
-2. `fetch_company({ companyDomain })` — sender's company LinkedIn page (description, industry, employee range, recent posts). REQUIRED — replaces what `enrich_sender` used to provide for `companySnapshot`.
+2. `fetch_company({ companyUrl })` — sender's company LinkedIn page (description, industry, employee range, recent posts). `companyUrl` is the LinkedIn company URL. REQUIRED — replaces what `enrich_sender` used to provide for `companySnapshot`.
 3. `WebSearch({ query: 'site:{companyDomain} ("case study" OR "customer story" OR testimonial OR "success story") "{companyName}"' })` — proof.
 4. `WebSearch({ query: '"{companyName}" {companyDomain} {currentYear} (funding OR raised OR seed OR series OR hiring OR launch OR "press release")' })` — growth/credibility.
 5. `WebSearch({ query: '"{companyName}" about product site:{companyDomain}' })` — positioning.
 
+**When only the profile URL is known** (a new customer gave nothing else), the
+company name, domain and LinkedIn company URL come from the profile, so the
+five calls cannot all go in one message. Call `fetch_linkedin_profile` alone
+first, then emit the other four together in the next message. If the profile
+does not show the company's website, call `fetch_company` next on its own and
+take the website from it, then emit the three searches together. Never guess
+the company or its domain from the handle. This order replaces "exactly these
+five … in a single assistant message" above for this case.
+
 **Self-check before you reply:** if your reply contains fewer than five
-`tool_use` blocks (after the optional `ToolSearch` setup turn), you are
-violating the protocol. Stop, rewrite the reply with all five.
+`tool_use` blocks (after the optional `ToolSearch` setup turn), or fewer than
+four when the profile was fetched first, you are violating the protocol.
+Stop, rewrite the reply with all of them.
 
 **Known limitation (`claude -p` headless mode):** Claude often serializes
 these calls one-per-turn even with explicit instructions. That's fine — the
@@ -137,6 +147,11 @@ signals, AND the campaign fixture/operator told you proof is required, you
 MAY issue ONE additional WebFetch on the most promising case-study URL from
 the proof WebSearch. Cap at one WebFetch. No subagents, no second WebSearch round.
 
+If the proof and positioning searches returned nothing from the company's own
+site (common when the company name is an ordinary word), you MAY issue that
+ONE WebFetch on the company's homepage instead, to read what it says it does
+and any customers it names. Same cap.
+
 If that still yields nothing, set `proofItemsFound: 0` in
 `complete_sender_research` and proceed; the brief can ship without proof.
 
@@ -157,16 +172,21 @@ If no reliable evidence is found, set counts to 0 and include that in `notes`.
 
 ## Progress UX
 
-Before issuing the parallel batch:
+In a chat host where every line you write is posted to the customer (Slack),
+write nothing here: the customer was already told research is under way, and
+the next thing they should read is the result. Tool names, "in parallel",
+time estimates and counts of proof items are not for customers.
+
+In a terminal host, before issuing the batch:
 
 ```
-Pulling sender profile + company snapshot + case studies + growth signals + positioning in parallel (~10s)...
+Researching the sender and company…
 ```
 
 After synthesis:
 
 ```
-Sender research ready — {proofItemsFound} proof items, {credibilitySignalsFound} credibility signals.
+Sender research ready.
 ```
 
 ## What Changed From The Previous Protocol