@sellable/install 0.1.69 → 0.1.71

package/README.md

@@ -33,7 +33,13 @@ Auth is stored once at:
 ~/.sellable/config.json
 ```
 
-Claude Code and Codex are configured to launch the same packaged MCP server.
+Claude Code and Codex are configured to launch the same packaged MCP server. The
+installer also writes Sellable source-scout agents for both hosts from the
+packaged `agents/` registry: Claude Code gets `source-scout-*` subagents, and
+Codex gets `source-scout-linkedin-engagement`, `source-scout-sales-nav`, and
+`source-scout-prospeo-contact`. The MCP exposes the same list through
+`get_source_scout_registry`, so adding a future scout starts in one registry
+entry instead of scattered prompt edits.
 
 ## Names
 

package/agents/registry.json

@@ -0,0 +1,147 @@
+{
+  "version": 1,
+  "agents": [
+    {
+      "id": "linkedin-engagement",
+      "name": "source-scout-linkedin-engagement",
+      "promptFile": "source-scout-linkedin-engagement.md",
+      "displayName": "LinkedIn Engagement Scout",
+      "provider": "signal-discovery",
+      "lane": "linkedin-engagement",
+      "legacy": {
+        "codex": [
+          {
+            "name": "linkedin_engagement_scout",
+            "filename": "linkedin-engagement-scout.toml"
+          }
+        ],
+        "claude": [
+          {
+            "name": "lead-explorer-signals",
+            "filename": "lead-explorer-signals.md"
+          }
+        ]
+      },
+      "codex": {
+        "description": "Sellable lead-source scout for LinkedIn post engagement and active conversation signals.",
+        "modelReasoningEffort": "medium",
+        "sandboxMode": "read-only",
+        "nicknameCandidates": [
+          "LinkedIn Engagement Scout",
+          "Post Scout",
+          "Engager Scout"
+        ]
+      },
+      "claude": {
+        "description": "Use proactively as a background Sellable source scout when find-leads or create-campaign needs LinkedIn post engagement, Signals, or active conversation evidence.",
+        "model": "inherit",
+        "background": true,
+        "maxTurns": 8,
+        "color": "blue",
+        "tools": [
+          "Read",
+          "Grep",
+          "Glob",
+          "mcp__sellable__get_provider_prompt",
+          "mcp__sellable__search_signals",
+          "mcp__sellable__fetch_post_engagers"
+        ]
+      }
+    },
+    {
+      "id": "sales-nav",
+      "name": "source-scout-sales-nav",
+      "promptFile": "source-scout-sales-nav.md",
+      "displayName": "Sales Nav Scout",
+      "provider": "sales-nav",
+      "lane": "sales-nav",
+      "legacy": {
+        "codex": [
+          {
+            "name": "sales_nav_scout",
+            "filename": "sales-nav-scout.toml"
+          }
+        ],
+        "claude": [
+          {
+            "name": "lead-explorer-sales-nav",
+            "filename": "lead-explorer-sales-nav.md"
+          }
+        ]
+      },
+      "codex": {
+        "description": "Sellable lead-source scout for Sales Navigator role, company, and activity filters.",
+        "modelReasoningEffort": "medium",
+        "sandboxMode": "read-only",
+        "nicknameCandidates": [
+          "Sales Nav Scout",
+          "Role Filter Scout",
+          "Activity Scout"
+        ]
+      },
+      "claude": {
+        "description": "Use proactively as a background Sellable source scout when find-leads or create-campaign needs Sales Navigator title, company, geography, or activity-filter evidence.",
+        "model": "inherit",
+        "background": true,
+        "maxTurns": 8,
+        "color": "cyan",
+        "tools": [
+          "Read",
+          "Grep",
+          "Glob",
+          "mcp__sellable__get_provider_prompt",
+          "mcp__sellable__lookup_sales_nav_filter",
+          "mcp__sellable__search_sales_nav"
+        ]
+      }
+    },
+    {
+      "id": "prospeo-contact",
+      "name": "source-scout-prospeo-contact",
+      "promptFile": "source-scout-prospeo-contact.md",
+      "displayName": "Prospeo Contact Scout",
+      "provider": "prospeo",
+      "lane": "prospeo-contact",
+      "legacy": {
+        "codex": [
+          {
+            "name": "prospeo_contact_scout",
+            "filename": "prospeo-contact-scout.toml"
+          }
+        ],
+        "claude": [
+          {
+            "name": "lead-explorer-prospeo",
+            "filename": "lead-explorer-prospeo.md"
+          }
+        ]
+      },
+      "codex": {
+        "description": "Sellable lead-source scout for Prospeo account/domain and broad contact expansion.",
+        "modelReasoningEffort": "medium",
+        "sandboxMode": "read-only",
+        "nicknameCandidates": [
+          "Prospeo Contact Scout",
+          "Domain Scout",
+          "Contact Scout"
+        ]
+      },
+      "claude": {
+        "description": "Use proactively as a background Sellable source scout when find-leads or create-campaign needs Prospeo account, domain-list, CSV-domain, or verified-contact evidence.",
+        "model": "inherit",
+        "background": true,
+        "maxTurns": 8,
+        "color": "green",
+        "tools": [
+          "Read",
+          "Grep",
+          "Glob",
+          "mcp__sellable__get_provider_prompt",
+          "mcp__sellable__load_csv_domains",
+          "mcp__sellable__save_domain_filters",
+          "mcp__sellable__search_prospeo"
+        ]
+      }
+    }
+  ]
+}

package/agents/source-scout-linkedin-engagement.md

@@ -0,0 +1,41 @@
+You are the LinkedIn Engagement Scout for Sellable find-leads.
+
+Your job is to test whether active LinkedIn posts and engagers can produce a warm first-send list for the campaign. Work only on this source lane. Do not import leads, create campaigns, write campaign artifacts, draft messages, ask the user questions, or make the final source decision.
+
+Required first step:
+
+- Load the canonical provider prompt before searching: `get_provider_prompt({ provider: "signal-discovery", confirmed: true })`.
+
+Use the inherited Sellable MCP tools when available:
+
+- `search_signals` to find recent post lanes.
+- `fetch_post_engagers` to sample engagers from selected posts.
+
+Process:
+
+1. Read the campaign brief, kickoff doc, or lane prompt supplied by the parent.
+2. Search 3-5 keyword/topic lanes, favoring fresh posts from the last 7-14 days.
+3. Select 3-5 promising posts when available.
+4. Fetch or sample engagers for selected posts and score rough ICP fit from visible headline/display-name cues only. Do not enrich people during viability estimation.
+5. Estimate usable prospects per selected post from sampled pass rate. If the sample is good but volume is low, say how many more similar posts should be added or scraped.
+6. Return false positives and dead ends explicitly.
+
+Return a concise structured result with:
+
+- `source_lane`
+- `provider_prompt_loaded`
+- `keyword_lanes` with timeframe, raw posts found, finalist posts reviewed
+- `selected_posts` with URL/title, author/topic, age, engager count, sampled engagers, good fits as n/N, estimated usable prospects per post, use/discard
+- `sample_leads`, if any
+- `estimated_good_fit_range`
+- `expected_reply_rate_range`, directional if inferred
+- `false_positive_patterns`
+- `recommendation`
+- `confidence`
+
+Evidence standards:
+
+- Do not trust raw post volume without inspecting finalist post quality.
+- Prefer sample-based pass rates over intuition.
+- If `fetch_post_engagers` is unavailable or fails, report that explicitly and mark the estimate lower-confidence.
+- Keep LinkedIn Engagement viable when selected posts can produce roughly 150+ ICP-fit warm prospects before final filtering, even if Sales Nav is more scalable.

package/agents/source-scout-prospeo-contact.md

@@ -0,0 +1,43 @@
+You are the Prospeo Contact Scout for Sellable find-leads.
+
+Your job is to test whether Prospeo can produce verified-contact scale for the campaign through account/domain targeting or broad persona expansion. Work only on this source lane. Do not import leads, create campaigns, write campaign artifacts, draft messages, ask the user questions, or make the final source decision.
+
+Required first step:
+
+- Load the canonical provider prompt before searching: `get_provider_prompt({ provider: "prospeo", confirmed: true })`.
+
+Use the inherited Sellable MCP tools when available:
+
+- `load_csv_domains` when the parent supplies a CSV on disk and no `domainFilterId` exists.
+- `save_domain_filters` when the parent supplies pasted/raw include or exclude domains and no `domainFilterId` exists.
+- `search_prospeo` for campaignless people previews.
+
+Process:
+
+1. Read the campaign brief, source intake, kickoff doc, or lane prompt supplied by the parent.
+2. Identify whether this is domain/account targeting or broad persona expansion.
+3. For domain targeting, use or create the standalone `domainFilterId` before searching; never pass raw domains directly into `search_prospeo`.
+4. Run the narrowest useful Prospeo people preview and 1-2 refinements if quality or scale is unclear.
+5. Call out that Prospeo gives contact/account coverage but usually weaker LinkedIn intent than LinkedIn Engagement or Sales Nav activity slices.
+
+Return a concise structured result with:
+
+- `source_lane`
+- `provider_prompt_loaded`
+- `mode`
+- `domain_filter_or_account_inputs`
+- `exact_search_recipe`
+- `raw_result_count`
+- `sampled_people` and good fits as n/N
+- `estimated_good_fit_range_after_cleanup`
+- `expected_reply_rate_range`, directional if inferred
+- `sample_leads`
+- `false_positive_patterns`
+- `recommendation`
+- `confidence`
+
+Evidence standards:
+
+- Never pass raw domains, company website arrays, or company-name arrays into `search_prospeo`.
+- If the user supplied company names rather than domains, report that domain resolution is required before this lane can run safely.
+- Treat Prospeo as an account/contact coverage lane, not as proof of fresh LinkedIn intent.

package/agents/source-scout-sales-nav.md

@@ -0,0 +1,44 @@
+You are the Sales Nav Scout for Sellable find-leads.
+
+Your job is to test whether Sales Navigator filters can produce a scalable, high-fit lead pool for the campaign. Work only on this source lane. Do not import leads, create campaigns, write campaign artifacts, draft messages, ask the user questions, or make the final source decision.
+
+Required first step:
+
+- Load the canonical provider prompt before searching: `get_provider_prompt({ provider: "sales-nav", confirmed: true })`.
+
+Use the inherited Sellable MCP tools when available:
+
+- `lookup_sales_nav_filter` before any dynamic Sales Nav filter.
+- `search_sales_nav` for campaignless preview searches.
+
+Process:
+
+1. Read the campaign brief, kickoff doc, or lane prompt supplied by the parent.
+2. Preserve target role names with `CURRENT_TITLE` lookups; do not rely on seniority alone when the brief names concrete roles.
+3. When `lookup_sales_nav_filter` returns multiple title options, choose the closest semantic title match instead of the first result.
+4. Build a broad-but-reasonable baseline from role/title, geography, company size, industry/account context, and recent LinkedIn activity when relevant.
+5. Run the baseline plus 1-2 refinements if the first pass is noisy or under-scaled.
+6. Verify filters actually applied: returned search URL contains filters, first-page rows match the intended lane, and result count does not look like an unfiltered pool.
+
+Return a concise structured result with:
+
+- `source_lane`
+- `provider_prompt_loaded`
+- `exact_filter_recipe`
+- `lookup_ids_used`
+- `raw_result_count`
+- `sampled_people` and good fits as n/N
+- `estimated_good_fit_range_after_cleanup`
+- `expected_acceptance_rate_range`, directional if inferred
+- `expected_reply_rate_range`, directional if inferred
+- `sample_leads`
+- `false_positive_patterns`
+- `recommendation`
+- `confidence`
+
+Evidence standards:
+
+- Optimize for a useful prospect pool, not max volume at any cost.
+- Bias toward `POSTED_ON_LINKEDIN` for reply-likelihood when the pool still has enough scale.
+- Do not hand-wave missing filter IDs.
+- If Sales Nav returns a giant unfiltered pool, discard that result and retry with valid filters before recommending it.

package/bin/sellable-install.mjs

@@ -465,6 +465,7 @@ const CREATE_CAMPAIGN_ALLOWED_TOOLS = [
   "mcp__sellable__get_subskill_asset",
   "mcp__sellable__search_subskill_prompts",
   "mcp__sellable__get_provider_prompt",
+  "mcp__sellable__get_source_scout_registry",
   "mcp__sellable__get_message_prompt",
   "mcp__sellable__get_active_workspace",
   "mcp__sellable__list_senders",
@@ -1089,110 +1090,129 @@ function codexPluginSkills() {
   ];
 }
 
+function installerPackageRoot() {
+  return join(dirname(fileURLToPath(import.meta.url)), "..");
+}
+
+function agentTemplateRoot() {
+  const packagedRoot = join(installerPackageRoot(), "agents");
+  if (existsSync(join(packagedRoot, "registry.json"))) {
+    return packagedRoot;
+  }
+
+  // Dev fallback for running the installer directly from the repo before
+  // sync-skill-templates has copied the package templates.
+  const repoRoot = join(installerPackageRoot(), "..", "..");
+  const canonicalRoot = join(repoRoot, "mcp", "sellable", "agents");
+  if (existsSync(join(canonicalRoot, "registry.json"))) {
+    return canonicalRoot;
+  }
+
+  throw new Error(
+    `Sellable source scout agent templates missing. Expected ${join(
+      packagedRoot,
+      "registry.json"
+    )}`
+  );
+}
+
+function loadCanonicalAgents() {
+  const root = agentTemplateRoot();
+  const registry = JSON.parse(readFileSync(join(root, "registry.json"), "utf8"));
+  if (!Array.isArray(registry.agents)) {
+    throw new Error("Sellable agent registry is missing agents array.");
+  }
+
+  return registry.agents.map((agent) => {
+    const promptPath = join(root, agent.promptFile || "");
+    if (!agent.id || !agent.name || !agent.promptFile || !existsSync(promptPath)) {
+      throw new Error(`Invalid Sellable agent registry entry: ${agent.id || "unknown"}`);
+    }
+    if (agent.codex?.name && agent.codex.name !== agent.name) {
+      throw new Error(
+        `Sellable agent ${agent.id} has divergent Codex name ${agent.codex.name}; use canonical name ${agent.name}.`
+      );
+    }
+    if (agent.claude?.name && agent.claude.name !== agent.name) {
+      throw new Error(
+        `Sellable agent ${agent.id} has divergent Claude name ${agent.claude.name}; use canonical name ${agent.name}.`
+      );
+    }
+
+    return {
+      ...agent,
+      prompt: readFileSync(promptPath, "utf8").trimEnd(),
+    };
+  });
+}
+
+function codexAgentFilename(agent) {
+  return agent.codex?.filename || `${agent.name}.toml`;
+}
+
+function claudeAgentFilename(agent) {
+  return agent.claude?.filename || `${agent.name}.md`;
+}
+
+function legacyCodexCustomAgents() {
+  return loadCanonicalAgents().flatMap((agent) => agent.legacy?.codex || []);
+}
+
+function legacyClaudeCustomAgents() {
+  return loadCanonicalAgents().flatMap((agent) => agent.legacy?.claude || []);
+}
+
+function tomlArray(values) {
+  return `[${values.map((value) => quoteToml(value)).join(", ")}]`;
+}
+
+function tomlMultilineString(value) {
+  const escaped = String(value).replace(/\\/g, "\\\\").replace(/"""/g, '\\"""');
+  return `"""\n${escaped}\n"""`;
+}
+
+function generateCodexAgentToml(agent) {
+  const codex = agent.codex;
+  return `name = ${quoteToml(agent.name)}
+description = ${quoteToml(codex.description)}
+model_reasoning_effort = ${quoteToml(codex.modelReasoningEffort || "medium")}
+sandbox_mode = ${quoteToml(codex.sandboxMode || "read-only")}
+nickname_candidates = ${tomlArray(codex.nicknameCandidates || [agent.displayName])}
+developer_instructions = ${tomlMultilineString(agent.prompt)}
+`;
+}
+
 function codexCustomAgents() {
-  const commonPrefix = `You are part of the Sellable find-leads source scout.
+  return loadCanonicalAgents().map((agent) => ({
+    name: agent.name,
+    filename: codexAgentFilename(agent),
+    content: generateCodexAgentToml(agent),
+  }));
+}
 
-Work only on your assigned source lane. Do not import leads, create campaigns, write campaign artifacts, or draft messages. Return concise structured evidence to the parent agent so it can synthesize the lead-source decision.`;
+function generateClaudeAgentMd(agent) {
+  const claude = agent.claude;
+  return `---
+name: ${agent.name}
+description: ${JSON.stringify(claude.description)}
+tools: ${(claude.tools || []).join(", ")}
+model: ${claude.model || "inherit"}
+background: ${claude.background === true ? "true" : "false"}
+maxTurns: ${Number.isFinite(claude.maxTurns) ? claude.maxTurns : 8}
+color: ${claude.color || "blue"}
+---
 
-  return [
-    {
-      filename: "linkedin-engagement-scout.toml",
-      content: `name = "linkedin_engagement_scout"
-description = "Sellable lead-source scout for LinkedIn post engagement and active conversation signals."
-model_reasoning_effort = "medium"
-sandbox_mode = "read-only"
-nickname_candidates = ["LinkedIn Engagement Scout", "Post Scout", "Engager Scout"]
-developer_instructions = """
-${commonPrefix}
-
-Your lane is LinkedIn Engagement. Internally, use the signal-discovery provider prompt and the Signals tools when available.
-
-Use the inherited Sellable MCP tools when available:
-- get_provider_prompt for signal-discovery before searching
-- search_signals to find recent post lanes
-- fetch_post_engagers to sample engagers from selected posts
-
-Process:
-1. Search 3-5 keyword/topic lanes, favoring fresh posts from the last 7-14 days.
-2. Select 3-5 promising posts when available.
-3. Fetch or sample engagers for selected posts and score rough ICP fit from visible headline/display cues.
-4. Estimate usable prospects per selected post from sampled pass rate.
-5. If the sample is good but volume is low, say how many more similar posts should be added or scraped.
-
-Return:
-- keyword lanes searched, timeframe, raw posts found, finalist posts reviewed
-- selected post URL/title, author/topic, age, engager count, sampled engagers, good fits as n/N, estimated usable prospects per post, use/discard
-- sample leads if any
-- estimated good-fit range, directional reply-rate range, false positives, recommendation, confidence
-"""
-`,
-    },
-    {
-      filename: "sales-nav-scout.toml",
-      content: `name = "sales_nav_scout"
-description = "Sellable lead-source scout for Sales Navigator role, company, and activity filters."
-model_reasoning_effort = "medium"
-sandbox_mode = "read-only"
-nickname_candidates = ["Sales Nav Scout", "Role Filter Scout", "Activity Scout"]
-developer_instructions = """
-${commonPrefix}
-
-Your lane is Sales Nav.
-
-Use the inherited Sellable MCP tools when available:
-- get_provider_prompt for sales-nav before searching
-- lookup_sales_nav_filter before dynamic filters
-- search_sales_nav for campaignless preview searches
-
-Process:
-1. Preserve target role names with CURRENT_TITLE lookups; do not rely on seniority alone when the brief names concrete roles.
-2. Build a broad-but-reasonable baseline from role/title, geography, company size, industry/account context, and recent LinkedIn activity when relevant.
-3. Run the baseline plus 1-2 refinements if the first pass is noisy or under-scaled.
-4. Verify filters actually applied: search URL contains filters, first-page rows match the intended lane, and result count does not look like an unfiltered pool.
-
-Return:
-- exact filter recipe and lookup IDs used
-- raw result count, sampled people, good fits as n/N
-- estimated good-fit range after cleanup
-- directional acceptance/reply-rate ranges
-- sample leads, false positives, recommendation, confidence
-"""
-`,
-    },
-    {
-      filename: "prospeo-contact-scout.toml",
-      content: `name = "prospeo_contact_scout"
-description = "Sellable lead-source scout for Prospeo account/domain and broad contact expansion."
-model_reasoning_effort = "medium"
-sandbox_mode = "read-only"
-nickname_candidates = ["Prospeo Contact Scout", "Domain Scout", "Contact Scout"]
-developer_instructions = """
-${commonPrefix}
-
-Your lane is Prospeo Contact.
-
-Use the inherited Sellable MCP tools when available:
-- get_provider_prompt for prospeo before searching
-- load_csv_domains when the parent supplies a CSV or domain list and no domainFilterId exists
-- search_prospeo for campaignless people previews
-
-Process:
-1. Identify whether this is domain/account targeting or broad persona expansion.
-2. For domain targeting, use or create the standalone domainFilterId before searching; never pass raw domains directly into search_prospeo.
-3. Run the narrowest useful Prospeo people preview and 1-2 refinements if quality or scale is unclear.
-4. Call out that Prospeo gives contact/account coverage but usually weaker LinkedIn intent than LinkedIn Engagement or Sales Nav activity slices.
-
-Return:
-- mode and domain/account inputs
-- exact search recipe
-- raw result count, sampled people, good fits as n/N
-- estimated good-fit range after cleanup
-- directional reply-rate range
-- sample leads, false positives, recommendation, confidence
-"""
-`,
-    },
-  ];
+${agent.prompt}
+`;
+}
+
+function claudeCustomAgents() {
+  return loadCanonicalAgents().map((agent) => ({
+    name: agent.name,
+    filename: claudeAgentFilename(agent),
+    tools: agent.claude.tools || [],
+    content: generateClaudeAgentMd(agent),
+  }));
 }
 
 function writeCodexPluginSkills(pluginRoot, opts) {
@@ -1214,6 +1234,27 @@ function writeCodexCustomAgents(home, opts) {
   for (const agent of codexCustomAgents()) {
     writeFile(join(home, "agents", agent.filename), agent.content, opts);
   }
+  for (const agent of legacyCodexCustomAgents()) {
+    const legacyPath = join(home, "agents", agent.filename);
+    logVerbose(`${C.grey}Removing legacy Codex scout agent ${legacyPath}${C.reset}`);
+    if (!opts.dryRun) rmSync(legacyPath, { force: true });
+  }
+}
+
+function claudeHome() {
+  return join(homedir(), ".claude");
+}
+
+function writeClaudeCustomAgents(opts) {
+  const home = claudeHome();
+  for (const agent of claudeCustomAgents()) {
+    writeFile(join(home, "agents", agent.filename), agent.content, opts);
+  }
+  for (const agent of legacyClaudeCustomAgents()) {
+    const legacyPath = join(home, "agents", agent.filename);
+    logVerbose(`${C.grey}Removing legacy Claude scout agent ${legacyPath}${C.reset}`);
+    if (!opts.dryRun) rmSync(legacyPath, { force: true });
+  }
 }
 
 function installCodexDesktopPlugin(opts) {
@@ -1322,6 +1363,24 @@ enabled = false`
       "default_mode_request_user_input",
       true
     );
+    content = upsertTomlTable(
+      content,
+      "agents",
+      `[agents]
+max_threads = 6
+max_depth = 1`
+    );
+    for (const agent of legacyCodexCustomAgents()) {
+      content = removeTomlSection(content, `agents.${agent.name}`);
+    }
+    for (const agent of codexCustomAgents()) {
+      content = upsertTomlTable(
+        content,
+        `agents.${agent.name}`,
+        `[agents.${agent.name}]
+config_file = ${quoteToml(join(home, "agents", agent.filename))}`
+      );
+    }
     writeFileSync(configPath, `${content.trimEnd()}\n`, { mode: 0o600 });
   } else {
     logVerbose(
@@ -1334,6 +1393,7 @@ enabled = false`
       `${C.grey}+ enable [features].default_mode_request_user_input in ${configPath}${C.reset}`
     );
     logVerbose(`${C.grey}+ write Codex custom scout agents in ${home}/agents${C.reset}`);
+    logVerbose(`${C.grey}+ register Codex source scout agents in ${configPath}${C.reset}`);
   }
 
   return {
@@ -1397,12 +1457,14 @@ function installClaude(opts) {
     }
     throw new Error(message);
   }
+  writeClaudeCustomAgents(opts);
   if (opts.server === "hosted") {
     run(
       "claude",
       ["mcp", "add", "--transport", "http", "sellable", opts.hostedUrl],
       opts
     );
+    patchClaudeAlwaysLoad(opts);
     return true;
   }
   const [command, args] = mcpCommand(opts);
@@ -1517,6 +1579,30 @@ function verify(opts) {
         ? "Claude CLI present"
         : "Claude CLI missing",
     });
+    const claudeAgentPaths = claudeCustomAgents().map((agent) =>
+      join(claudeHome(), "agents", agent.filename)
+    );
+    const hasClaudeScouts = claudeAgentPaths.every((agentPath) =>
+      existsSync(agentPath)
+    );
+    checks.push({
+      ok: hasClaudeScouts,
+      label: hasClaudeScouts
+        ? "Claude custom scout agents present"
+        : "Claude custom scout agents missing",
+    });
+    const claudeAgentsHaveTools = claudeCustomAgents().every((agent) => {
+      const agentPath = join(claudeHome(), "agents", agent.filename);
+      if (!existsSync(agentPath)) return false;
+      const content = readFileSync(agentPath, "utf8");
+      return agent.tools.every((tool) => content.includes(tool));
+    });
+    checks.push({
+      ok: claudeAgentsHaveTools,
+      label: claudeAgentsHaveTools
+        ? "Claude scout MCP tool allowlists present"
+        : "Claude scout MCP tool allowlists missing",
+    });
   }
   if (opts.host === "codex" || opts.host === "all") {
     checks.push({
@@ -1572,6 +1658,15 @@ function verify(opts) {
     const configContent = existsSync(configPath)
       ? readFileSync(configPath, "utf8")
       : "";
+    const hasCodexAgentRegistrations = codexCustomAgents().every((agent) =>
+      configContent.includes(`[agents.${agent.name}]`)
+    );
+    checks.push({
+      ok: hasCodexAgentRegistrations,
+      label: hasCodexAgentRegistrations
+        ? "Codex custom scout agents registered"
+        : "Codex custom scout agents unregistered",
+    });
     const hasFlag = configContent.includes(
       "default_mode_request_user_input = true"
     );
@@ -1720,6 +1815,9 @@ function printNextSteps(installedHosts, authReused) {
     console.log(`        ${C.green}✓${C.reset} Skills installed`);
     console.log(`        ${C.green}✓${C.reset} Codex source scout agents installed`);
   }
+  if (hasClaude) {
+    console.log(`        ${C.green}✓${C.reset} Claude source scout agents installed`);
+  }
   if (authReused) {
     console.log(
       `        ${C.green}✓${C.reset} Existing session detected — no need to sign in again`
@@ -1797,6 +1895,9 @@ function runUninstall() {
       after = removeTomlSection(after, "marketplaces.sellable");
       after = removeTomlSection(after, 'plugins."sellable@sellable"');
       after = removeTomlSection(after, 'plugins."sellable@sellable-local"');
+      for (const agent of [...codexCustomAgents(), ...legacyCodexCustomAgents()]) {
+        after = removeTomlSection(after, `agents.${agent.name}`);
+      }
       // Collapse 3+ blank lines that the removals may leave behind.
       after = after.replace(/\n{3,}/g, "\n\n");
       if (after !== before) {
@@ -1817,6 +1918,19 @@ function runUninstall() {
     skipped.push(`Codex config not found at ${codexConfigPath}`);
   }
 
+  for (const agent of [...codexCustomAgents(), ...legacyCodexCustomAgents()]) {
+    const agentPath = join(codexHome(), "agents", agent.filename);
+    if (!existsSync(agentPath)) continue;
+    try {
+      rmSync(agentPath, { force: true });
+      removed.push(`${agentPath}`);
+    } catch (err) {
+      console.log(
+        `  ${C.yellow}!${C.reset} Could not remove ${agentPath}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+
   // 2) Claude Code MCP removal
   if (commandExists("claude")) {
     const r = spawnSync("claude", ["mcp", "remove", "sellable"], {
@@ -1831,6 +1945,19 @@ function runUninstall() {
     skipped.push(`Claude Code CLI not found`);
   }
 
+  for (const agent of [...claudeCustomAgents(), ...legacyClaudeCustomAgents()]) {
+    const agentPath = join(claudeHome(), "agents", agent.filename);
+    if (!existsSync(agentPath)) continue;
+    try {
+      rmSync(agentPath, { force: true });
+      removed.push(`${agentPath}`);
+    } catch (err) {
+      console.log(
+        `  ${C.yellow}!${C.reset} Could not remove ${agentPath}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+
   // 3) Surgical removal of Sellable-installed artifacts inside ~/.sellable/
   const sellableDir = join(homedir(), ".sellable");
   if (existsSync(sellableDir)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/install",
-  "version": "0.1.69",
+  "version": "0.1.71",
   "type": "module",
   "description": "One-command installer for Sellable MCP in Claude Code and Codex",
   "bin": {
@@ -12,6 +12,7 @@
   },
   "files": [
     "bin",
+    "agents",
     "skill-templates",
     "README.md"
   ],

package/skill-templates/create-campaign.md

@@ -11,6 +11,7 @@ allowed-tools:
   - mcp__sellable__get_subskill_asset
   - mcp__sellable__search_subskill_prompts
   - mcp__sellable__get_provider_prompt
+  - mcp__sellable__get_source_scout_registry
   - mcp__sellable__get_message_prompt
   - mcp__sellable__get_active_workspace
   - mcp__sellable__list_senders
@@ -102,11 +103,15 @@ scout those angles as independent branches when the host can actually do it:
 LinkedIn Engagement / active post engagers (internal `signal-discovery`
 provider prompt), Sales Nav / title + company filters, and Prospeo Contact /
 domains only when relevant. In Codex, explicitly spawn the named custom scouts
-`linkedin_engagement_scout`, `sales_nav_scout`, and `prospeo_contact_scout` for
+`source-scout-linkedin-engagement`, `source-scout-sales-nav`, and `source-scout-prospeo-contact` for
 the credible lanes; Codex does not infer subagent fan-out from generic source
-comparison wording. In Claude Code, keep using the existing Task agents under
-`.claude/agents/`. If the host runs them sequentially, do not claim they ran in
-parallel. In chat, call the downstream copy stage `message generation`;
+comparison wording. In Claude Code, invoke the generated `source-scout-*`
+Task/Agent subagents for all credible lanes in one assistant message; the
+installer writes them from the same canonical Sellable agent registry with
+explicit Sellable MCP tool allowlists. The create-campaign-v2 subskill calls
+`get_source_scout_registry` before dispatch so the current registry, not this
+copy, is the runtime source of truth. If the host runs them sequentially, do not
+claim they ran in parallel. In chat, call the downstream copy stage `message generation`;
 `message-validation.md` is only an internal proof artifact.
 
 Use rendered Markdown for user review surfaces, not fenced code blocks. Keep