@sellable/install 0.1.68 → 0.1.70

package/README.md

@@ -33,7 +33,11 @@ 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 `lead-explorer-*` subagents, and
+Codex gets `linkedin_engagement_scout`, `sales_nav_scout`, and
+`prospeo_contact_scout`.
 
 ## Names
 

package/agents/linkedin-engagement-scout.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/prospeo-contact-scout.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/registry.json

@@ -0,0 +1,108 @@
+{
+  "version": 1,
+  "agents": [
+    {
+      "id": "linkedin-engagement-scout",
+      "promptFile": "linkedin-engagement-scout.md",
+      "displayName": "LinkedIn Engagement Scout",
+      "codex": {
+        "name": "linkedin_engagement_scout",
+        "filename": "linkedin-engagement-scout.toml",
+        "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": {
+        "name": "lead-explorer-signals",
+        "filename": "lead-explorer-signals.md",
+        "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-scout",
+      "promptFile": "sales-nav-scout.md",
+      "displayName": "Sales Nav Scout",
+      "codex": {
+        "name": "sales_nav_scout",
+        "filename": "sales-nav-scout.toml",
+        "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": {
+        "name": "lead-explorer-sales-nav",
+        "filename": "lead-explorer-sales-nav.md",
+        "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-scout",
+      "promptFile": "prospeo-contact-scout.md",
+      "displayName": "Prospeo Contact Scout",
+      "codex": {
+        "name": "prospeo_contact_scout",
+        "filename": "prospeo-contact-scout.toml",
+        "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": {
+        "name": "lead-explorer-prospeo",
+        "filename": "lead-explorer-prospeo.md",
+        "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/sales-nav-scout.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

@@ -1089,6 +1089,111 @@ 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.promptFile || !existsSync(promptPath)) {
+      throw new Error(`Invalid Sellable agent registry entry: ${agent.id || "unknown"}`);
+    }
+    if (!agent.codex?.name || !agent.codex?.filename) {
+      throw new Error(`Sellable agent ${agent.id} is missing Codex metadata.`);
+    }
+    if (!agent.claude?.name || !agent.claude?.filename) {
+      throw new Error(`Sellable agent ${agent.id} is missing Claude metadata.`);
+    }
+
+    return {
+      ...agent,
+      prompt: readFileSync(promptPath, "utf8").trimEnd(),
+    };
+  });
+}
+
+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(codex.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() {
+  return loadCanonicalAgents().map((agent) => ({
+    name: agent.codex.name,
+    filename: agent.codex.filename,
+    content: generateCodexAgentToml(agent),
+  }));
+}
+
+function generateClaudeAgentMd(agent) {
+  const claude = agent.claude;
+  return `---
+name: ${claude.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"}
+---
+
+${agent.prompt}
+`;
+}
+
+function claudeCustomAgents() {
+  return loadCanonicalAgents().map((agent) => ({
+    name: agent.claude.name,
+    filename: agent.claude.filename,
+    tools: agent.claude.tools || [],
+    content: generateClaudeAgentMd(agent),
+  }));
+}
+
 function writeCodexPluginSkills(pluginRoot, opts) {
   for (const skill of codexPluginSkills()) {
     const skillRoot = join(pluginRoot, "skills", skill.dir);
@@ -1104,6 +1209,23 @@ function writeCodexPluginSkills(pluginRoot, opts) {
   }
 }
 
+function writeCodexCustomAgents(home, opts) {
+  for (const agent of codexCustomAgents()) {
+    writeFile(join(home, "agents", agent.filename), agent.content, opts);
+  }
+}
+
+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);
+  }
+}
+
 function installCodexDesktopPlugin(opts) {
   const home = codexHome();
   const configPath = join(home, "config.toml");
@@ -1154,6 +1276,7 @@ function installCodexDesktopPlugin(opts) {
     opts
   );
   writeCodexPluginSkills(pluginRoot, opts);
+  writeCodexCustomAgents(home, opts);
 
   if (!opts.dryRun) {
     rmSync(cacheRoot, { recursive: true, force: true });
@@ -1209,6 +1332,21 @@ enabled = false`
       "default_mode_request_user_input",
       true
     );
+    content = upsertTomlTable(
+      content,
+      "agents",
+      `[agents]
+max_threads = 6
+max_depth = 1`
+    );
+    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(
@@ -1220,6 +1358,8 @@ enabled = false`
     logVerbose(
       `${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 {
@@ -1283,12 +1423,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);
@@ -1403,6 +1545,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({
@@ -1442,10 +1608,31 @@ function verify(opts) {
         ? "Codex skill bundle present"
         : "Codex skill bundle missing",
     });
+    const codexAgentPaths = codexCustomAgents().map((agent) =>
+      join(codexHome(), "agents", agent.filename)
+    );
+    const hasCodexScouts = codexAgentPaths.every((agentPath) =>
+      existsSync(agentPath)
+    );
+    checks.push({
+      ok: hasCodexScouts,
+      label: hasCodexScouts
+        ? "Codex custom scout agents present"
+        : "Codex custom scout agents missing",
+    });
     const configPath = join(codexHome(), "config.toml");
     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"
     );
@@ -1592,6 +1779,10 @@ function printNextSteps(installedHosts, authReused) {
   if (hasCodex) {
     console.log(`        ${C.green}✓${C.reset} Codex Desktop plugin installed`);
     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(
@@ -1670,6 +1861,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()) {
+        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) {
@@ -1690,6 +1884,19 @@ function runUninstall() {
     skipped.push(`Codex config not found at ${codexConfigPath}`);
   }
 
+  for (const agent of codexCustomAgents()) {
+    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"], {
@@ -1704,6 +1911,19 @@ function runUninstall() {
     skipped.push(`Claude Code CLI not found`);
   }
 
+  for (const agent of claudeCustomAgents()) {
+    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.68",
+  "version": "0.1.70",
   "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

@@ -99,10 +99,17 @@ denominator, and sample basis.
 
 When the user has not supplied a source and multiple source angles are viable,
 scout those angles as independent branches when the host can actually do it:
-Signals / active LinkedIn posts, Sales Nav / title + company filters, and
-Prospeo / domains only when relevant. 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.
+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
+the credible lanes; Codex does not infer subagent fan-out from generic source
+comparison wording. In Claude Code, invoke the generated `lead-explorer-*`
+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. 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
 lines short, use indexed section labels and bullets, and translate internal