execute

• Plain JavaScript only. Author against the typed tool surface from

  get_schema

  , but the script body carries zero type annotations — a

  : Type

  ,

  as

  , or generic is a parse error that fails the whole run before any tool call, at zero spend.
• Open every script with a source-labeled comment:

  // user query: ...

  for the user's literal ask,

  // model query: ...

  for a derived step. Scripts without one are rejected before running.
• One I/O primitive:

  const r = await callTool(name, params)

  →

  { ok: true, data }

  or

  { ok: false, status, errorType, message }

  . Always branch on

  r.ok

  — a failed call does not abort the script, so an unchecked failure silently proceeds on empty data and looks like "they have no recent activity". That is exactly the failure that produces a fabricated hook.

• fields

  is a response whitelist. The result carries only the groups you list; an omitted group reads as

  undefined

  later and looks like missing data. List every group you read.
• Return the smallest projection. Only what the script returns reaches the model. For outreach that means hook candidates — date, one line of text, a link — never raw posts or whole profiles.
• Fan out independent work with

  await parallelMap(items, fn)

  ;

  chunk

  first where there is a per-call cap. Never parallelize cursor pagination or dependent stages.

  checkpoint(acc)

  after a costly stage so a timeout still returns the hooks you paid for.

1. Config backbone, never blocking. If

   config/persona-profile.md

   or

   config/gtm-config.md

   exist in the working directory, read them: the rep's voice (tone, sentence length, sign-off, never-do list), what they sell, who buys. If they don't exist, ask one inline question ("What do you sell, and what's your sign-off?") or point at the icp-builder skill, which writes both files from one LinkedIn URL. A missing config never blocks a draft — write in a plain, direct voice and say you did.
2. Confirm the ask in one line: WHO (person, account, or list) — CHANNEL (email / call / LinkedIn) — MOMENT (first touch / follow-up / reply / objection) — GOAL (a meeting? an answer? an intro?).
3. Pull the hook (next section). One sharp hook beats five soft ones.

• Write from a role-level insight ("every VP Eng at 300 people hits this") and label it as such — a good generic beats a fake specific.
• Pull a hook on a different person at the same account who is active — if you already have their profile URL (from the user's list, or from sales-prospecting / account-research, which do the person discovery), run Hook 1 on them instead.
• Use the account's own words:

  social_post_list_live

  keyed on

  company_domain

  gives the company feed when the individual is quiet.
• Recommend waiting for a signal and setting up the watcher in sales-prospecting's champion tracker.

• Line 1 — the hook. Their thing, dated, in their language. The reader should think "yes, I did that".
• Line 2 — the bridge. One sentence connecting their thing to the pain you solve.
• Line 3 — one concrete outcome. A number or a named customer situation, not a value prop.
• Line 4 — one ask. The lowest-friction version that still moves ("worth 15 minutes Thursday?" or "want me to send the two-line version?").
• Their sign-off, if the persona config carries one. The config written by icp-builder records tone and style but not a sign-off, so ask for it inline the first time and reuse it after.

• Opener + permission line ("caught you cold — 30 seconds and you can tell me to go away?").
• Reason for the call, tied to the same hook. Cold calls die on "just reaching out".
• Value hypothesis in one sentence, framed as a guess they can correct.
• 2-3 open discovery questions — how they handle it today, what it costs them.
• The ask: a meeting, not a sale.
• Objection branches, written out: not interested / send me an email / we already use something / no budget / gatekeeper. Each is one acknowledgment plus one question that keeps the call alive.
• 15-second voicemail and a one-line follow-up text, both referencing the same hook so the touches stack.

• Connection note — 300 characters max, no pitch. The hook plus a reason to connect.
• First DM — value or a smart question. Still no pitch.
• Follow-up — a soft ask, only after a reply or a signal.
• Break-up — one line, gracious, leaves the door open.

1. The cadence table first — day, channel, angle, personalization level. Vary the angle across touches: problem → proof → a different persona's pain → social proof → break-up. Never send the same idea five times in different words.
2. Then write every touch using types 1-3.
3. Mark each touch

   1:1

   (rep writes a custom line) vs

   merge-field

   (scales across the list), and flag exactly where the rep must add something only they know.
4. Hook freshness: touch 1 carries the pulled hook. By touch 4 that hook is two weeks old — either re-pull or switch to an angle that doesn't depend on recency. Say which in the table.

• Em dashes. Use a period or a comma.
• "I hope this finds you well", "I wanted to reach out", "quick question", "circling back", "just following up".
• "delve", "leverage", "streamline", "unlock", "elevate", "seamless", "robust".
• Rule-of-three constructions ("faster, cheaper, and more reliable").
• Negative parallelism ("not just X, but Y").
• Filler adverbs: "really", "actually", "truly", "incredibly".
• Fake familiarity ("Hope you're crushing it!") and fake urgency.
• Any sentence that would survive a find-and-replace of the company name. If it works for any company, it works for none.

parallelMap

limit: 3

// user query: draft outreach for these 40 accounts — pull a hook for each first
const people = inputs.people; // [{ name, profileUrl, company, domain }]
const cutoffMs = Date.now() - 60 * 24 * 3600 * 1000;

const hooks = await parallelMap(people, async (p) => {
  const r = await callTool("social_post_list_live", {
    professional_network_profile_url: p.profileUrl,
    limit: 3,                                        // 1 cr/post x 3 x N people — quote this before running
    fields: ["text", "date_posted", "post_type", "share_url"],
  });
  if (!r.ok) return { name: p.name, hook: null, reason: r.message };
  const fresh = (r.data.posts ?? [])
    .map(x => ({ date: x.date_posted, ms: Date.parse(x.date_posted ?? ""), url: x.share_url, text: (x.text ?? "").slice(0, 300) }))
    .filter(x => !Number.isNaN(x.ms) && x.ms >= cutoffMs);
  return { name: p.name, company: p.company, hook: fresh[0] ?? null, reason: fresh.length ? null : "no recent post" };
});
checkpoint(hooks);
return {
  withHook: hooks.filter(h => h.hook),
  needCompanyFallback: hooks.filter(h => !h.hook).map(h => ({ name: h.name, company: h.company, reason: h.reason })),
};

needCompanyFallback

"Business emails for 40 people: at most ~40 credits (1 per matched person). Adding personal emails and phones raises the ceiling to 5 per person, so ~200. Business only — go?"

// user query: get business emails for the 40 people on the list (worst case ~40 credits, confirmed)
const urls = inputs.profileUrls;
const batches = chunk(urls, 25); // hard cap: 25 URLs per call
const results = await parallelMap(batches, async (batch) => {
  const r = await callTool("person_contact_enrich", {
    professional_network_profile_urls: batch,
    fields: ["contact.business_emails"], // narrow the request; see the cost note below
  });
  return r.ok ? r.data : batch.map(u => ({ matched_on: u, matches: [], error: r.message }));
});
const rows = results.flat();
return {
  contacts: rows.map(m => ({
    url: m.matched_on,
    email: m.matches?.[0]?.person_data?.contact?.business_emails?.[0]?.email ?? null,
    status: m.matches?.[0]?.person_data?.contact?.business_emails?.[0]?.status ?? null,
  })),
  unmatched: rows.filter(m => !m.matches?.length).map(m => m.matched_on),
};

fields

credits_remaining

• Campaign CSV:

  email, first_name, last_name, company, title, linkedin_url, hook_text, hook_date, hook_url, personalization_line, tier

  . The hook, its date, and the link to it ride in the file so the rep can sanity-check every row before it sends.
• Campaign spec the user pastes into whatever sequencer they run: the sequence steps with the full copy per step, the merge fields used, send window and timezone, daily ramp (start at 20-30/day on a new domain), threading (follow-ups in-thread), and stop-on-reply ON.
• Deliverability guardrails in the spec: warmed domain, at most one link in touch 1, plain text over HTML, unsubscribe honored instantly.

• The hook comes first, and it is real or it is absent. Never fabricate a post, a quote, a round, a mutual connection, or a case study. "I couldn't find a recent signal for this person, here's a role-level angle instead" is a valid, honest answer.
• Date every reference in the draft and in your notes to the rep, so they can check it in five seconds.
• One hook, one idea, one ask per touch. Shorter beats clever.
• Never auto-send anything. Email drafts stay drafts. This skill never writes to a CRM; any log entry is yours to make before writing. Sequencer setup is a spec plus a CSV that the rep loads and starts themselves.
• Respect opt-outs completely and immediately. Never volume your way past a compliance limit; if the user wants that, it's theirs to own explicitly.
• No-slop rule on every deliverable (full list above): no em dashes, no "delve"/"leverage"/"streamline", no filler, nothing that survives a find-and-replace of the company name.
• Costs are real: state expected spend before post pulls, list fan-outs, or contact enrichment. Every

  execute

  response carries

  credits

  and

  credits_remaining

  ;

  account_credits

  (free) reports the balance.
• Every deliverable ends with the handoff question: copy in chat, a CSV plus campaign spec for your sequencer, or a rendered doc.
• Adapt the layout to the content — never let it hide anything. The brand system is fixed; the layout is not. If real content doesn't fit — a long company or person name, a 12-word title, 200 rows — change the layout, not the content: let the card grow, wrap instead of truncating, drop to one column, widen the column, raise the cap, or give the wide thing its own scroll container. Never solve a fit problem by clipping a card, ellipsing a name, or silently dropping rows. Where a cap really is unavoidable, say so in the UI ("showing the top 50 of 214"). Look at the rendered output and fix what's cut off before you hand it over.
• Icons in rendered output: Lucide, the dashboard's icon set, inlined as SVG with a

  currentColor

  stroke. No emojis in artifact UI.
• Photos and logos are free — use them in rendered output.

  basic_profile.profile_picture_permalink

  (person) rides in the

  basic_profile

  group of any person record handed to you;

  basic_info.logo_permalink

  (company) comes free from

  company_identify

  and from

  company_enrich

  's

  basic_info

  . Neither costs an extra credit. Base64-inline both as

  data:image/jpeg;base64,...

  URIs — the media CDN serves them as

  binary/octet-stream

  , so a remote

  <img src>

  renders blank. Monogram fallback when an image is missing.
• Artifact branding: copy is chat-native by default, and the CSV stays a plain data file — never render an artifact just to render one. But IF a deliverable is rendered as a page or document (an objection playbook, a sequence spec, a campaign one-pager), it carries the Crustdata brand lockup in the header or footer: a small uppercase "Powered by" eyebrow plus the official Crustdata wordmark, linking to crustdata.com. The wordmark pair ships in this skill's

  assets/

  —

  crustdata-logo-light.png

  (dark text, for light backgrounds) and

  crustdata-logo-dark.png

  (white text, for dark backgrounds). Base64-inline the theme-appropriate variant at ~17px height — never hotlink; rendered artifacts cannot fetch remote images. Brand accent:

  #5547E2

  (

  #8387FF

  on dark grounds). Body font: Geist when embeddable, else the system stack.

• A failed call is the dangerous case, not the obvious one.

  r.ok === false

  on a post pull looks identical to "this person doesn't post". Branch on it, report it as an error, and fall back to Hook 2 or Hook 3 — never let it become a generic first line dressed up as personalization.
• 403 naming a field = a plan-gated projection. Drop that field from

  fields

  and re-run. 403 naming the endpoint (contact enrichment is the common one) = the plan doesn't include it; say so plainly and hand off the list without emails rather than guessing address patterns.
• Empty posts, empty news, no open roles is a normal outcome, not a failure. Report which sources came back empty and take the no-hook path above.

• company_identify

  returns several matches for one domain — that's expected, it's fuzzy. Take the top

  confidence_score

  ; if two are close, name both and ask.
• Unmatched rows in a list run are reported by name, never dropped and never silently swapped for a template row.

• sales-prospecting — builds the list and fires the signals this skill writes on. Champion-tracker rows are the highest-converting input here.
• account-research — deep-dive an account before a big-ticket touch; its account plan gives you the pain map the bridge line needs.
• icp-builder — writes

  config/persona-profile.md

  (voice) and

  config/gtm-config.md

  (what you sell) from one LinkedIn URL, so drafts sound like the rep from run one.
• warm-path-workspace — when there's a warm route in, use it: a referral opener beats the best cold email you'll ever write.

• Crustdata MCP server (install.crustdata.com/mcp): a single Code Mode MCP exposing

  list_tools

  ,

  get_schema

  , and

  execute

  . All Crustdata data tools are reached inside an

  execute({ code })

  plain-JavaScript script via

  await callTool(name, params)

  — author against the typed surface from

  get_schema

  , but the script body carries zero type annotations (a type annotation is a parse error that fails the whole run). Tools used here:

  social_post_list_live

  ,

  company_identify

  ,

  company_enrich

  ,

  job_search

  ,

  person_contact_enrich

  (opt-in, cost-confirmed),

  account_credits

  .
• Nothing else. No sequencer credentials, no email-sending access, no CRM write access. Outbound leaves this skill as copy, a CSV, and a written campaign spec — the rep loads and starts it.