@sellable/mcp 0.1.60 → 0.1.62

package/dist/server.js

@@ -21,7 +21,7 @@ import { fetchCompany, fetchCompanyPosts, fetchLinkedInPosts, fetchLinkedInProfi
 import { getCampaignNavigationState, navigationToolDefinitions, } from "./tools/navigation.js";
 import { addOnDemandLeads, createOnDemandCampaign, createOnDemandTable, initOnDemandSequence, onDemandToolDefinitions, pauseOnDemandCampaign, startOnDemandCampaign, } from "./tools/one-off.js";
 import { processingToolDefinitions, upsertRubric } from "./tools/processing.js";
-import { completeSenderResearch, getMessagePrompt, getSubskillPrompt, listSubskillPrompts, promptToolDefinitions, searchSubskillPrompts, } from "./tools/prompts.js";
+import { completeSenderResearch, getMessagePrompt, getSubskillAsset, getSubskillPrompt, listSubskillPrompts, promptToolDefinitions, searchSubskillPrompts, } from "./tools/prompts.js";
 import { readinessToolDefinitions, waitForCampaignTableReady, waitForLeadListReady, } from "./tools/readiness.js";
 import { getRows, getTableRows, getTableRowsMinimal, rowToolDefinitions, } from "./tools/rows.js";
 import { addRubricItem, checkRubric, deleteRubricItem, draftRubrics, rubricToolDefinitions, saveRubrics, selectNecessaryRubrics, updateRubricItem, waitForRubricResults, } from "./tools/rubrics.js";
@@ -399,6 +399,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "get_subskill_prompt":
                 result = getSubskillPrompt(args?.subskillName, args?.offset, args?.limit);
                 break;
+            case "get_subskill_asset":
+                result = getSubskillAsset(args?.subskillName, args?.assetPath, args?.offset, args?.limit);
+                break;
             case "list_subskill_prompts":
                 result = listSubskillPrompts(args?.limit, args?.includePublic, args?.includeInternal);
                 break;

package/dist/tools/prompts.d.ts

@@ -24,6 +24,19 @@ export interface SubskillPromptResponse {
     chunkCount?: number;
     chunkingInstructions?: string;
 }
+export interface SubskillAssetResponse {
+    subskillName: string;
+    assetPath: string;
+    content: string;
+    contentLength: number;
+    offset?: number;
+    limit?: number;
+    hasMore: boolean;
+    nextOffset: number | null;
+    chunkIndex: number;
+    chunkCount: number;
+    chunkingInstructions?: string;
+}
 export interface ListSubskillPromptsResponse {
     total: number;
     matches: Array<{
@@ -60,6 +73,7 @@ export declare const promptToolDefinitions: ({
             includeInternal?: undefined;
             subskillName?: undefined;
             offset?: undefined;
+            assetPath?: undefined;
             query?: undefined;
             depth?: undefined;
             proofItemsFound?: undefined;
@@ -91,6 +105,7 @@ export declare const promptToolDefinitions: ({
             };
             subskillName?: undefined;
             offset?: undefined;
+            assetPath?: undefined;
             query?: undefined;
             depth?: undefined;
             proofItemsFound?: undefined;
@@ -125,6 +140,44 @@ export declare const promptToolDefinitions: ({
             };
             includePublic?: undefined;
             includeInternal?: undefined;
+            assetPath?: undefined;
+            query?: undefined;
+            depth?: undefined;
+            proofItemsFound?: undefined;
+            caseStudyItemsFound?: undefined;
+            credibilitySignalsFound?: undefined;
+            notes?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    _meta: {
+        "anthropic/maxResultSizeChars": number;
+    };
+    inputSchema: {
+        type: string;
+        properties: {
+            subskillName: {
+                type: string;
+                description: string;
+            };
+            assetPath: {
+                type: string;
+                description: string;
+            };
+            offset: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            includePublic?: undefined;
+            includeInternal?: undefined;
             query?: undefined;
             depth?: undefined;
             proofItemsFound?: undefined;
@@ -159,6 +212,7 @@ export declare const promptToolDefinitions: ({
             };
             subskillName?: undefined;
             offset?: undefined;
+            assetPath?: undefined;
             depth?: undefined;
             proofItemsFound?: undefined;
             caseStudyItemsFound?: undefined;
@@ -201,6 +255,7 @@ export declare const promptToolDefinitions: ({
             includeInternal?: undefined;
             subskillName?: undefined;
             offset?: undefined;
+            assetPath?: undefined;
             query?: undefined;
         };
         additionalProperties: boolean;
@@ -211,6 +266,7 @@ export declare const promptToolDefinitions: ({
 export declare function getMessagePrompt(): Promise<PromptResponse>;
 export declare function listSubskillPrompts(limit?: number, includePublic?: boolean, includeInternal?: boolean): ListSubskillPromptsResponse;
 export declare function getSubskillPrompt(subskillName: string, offset?: number, limit?: number): SubskillPromptResponse;
+export declare function getSubskillAsset(subskillName: string, assetPath: string, offset?: number, limit?: number): SubskillAssetResponse;
 export declare function completeSenderResearch(input?: CompleteSenderResearchInput): {
     readonly completedAt: string;
     readonly depth: "minimal-verification" | "deep-proof" | "parallel-batch";

package/dist/tools/prompts.js

@@ -1,5 +1,7 @@
+import * as fs from "fs";
+import * as path from "path";
 import { getApi } from "../api.js";
-import { getSkillByName, listSkills, stripFrontmatter } from "../skills.js";
+import { getSkillByName, listSkills, resolveSkillsDir, stripFrontmatter, } from "../skills.js";
 import { markCreateCampaignPromptLoaded, markResearchPromptLoaded, markSenderResearchCompleted, } from "./flow-preflight.js";
 // Chunk size sits below Claude Code's max-token cap on tool results
 // (empirically around ~50k chars — fetch_linkedin_profile breached at
@@ -71,6 +73,36 @@ export const promptToolDefinitions = [
             additionalProperties: false,
         },
     },
+    {
+        name: "get_subskill_asset",
+        description: "Load a packaged file that belongs to a Sellable subskill, such as core/flow.v2.json, core/auto-execute.yaml, or references/*.md. Use this instead of reading local repo files so Claude Code and Codex packaged runs share the same config.",
+        _meta: {
+            "anthropic/maxResultSizeChars": 200_000,
+        },
+        inputSchema: {
+            type: "object",
+            properties: {
+                subskillName: {
+                    type: "string",
+                    description: "Subskill name that owns the asset directory.",
+                },
+                assetPath: {
+                    type: "string",
+                    description: "Path relative to the subskill directory, for example core/flow.v2.json or references/sample-validation-loop.md.",
+                },
+                offset: {
+                    type: "number",
+                    description: "Optional character offset for chunked asset reads. Use for large reference files.",
+                },
+                limit: {
+                    type: "number",
+                    description: `Optional max characters to return for chunked asset reads. Defaults to ${DEFAULT_SUBSKILL_PROMPT_CHUNK_CHARS} for large assets and is capped at ${MAX_SUBSKILL_PROMPT_CHUNK_CHARS}.`,
+                },
+            },
+            required: ["subskillName", "assetPath"],
+            additionalProperties: false,
+        },
+    },
     {
         name: "search_subskill_prompts",
         description: "Search Sellable subskills by name/description. Use this before get_subskill_prompt if you are unsure which prompt to load.",
@@ -169,53 +201,104 @@ function markSubskillPromptLoaded(subskillName) {
         markResearchPromptLoaded("prospect", "research-prospect");
     }
 }
-export function getSubskillPrompt(subskillName, offset, limit) {
-    const skill = getSkillByName(subskillName);
-    if (!skill) {
-        throw new Error(`Unknown subskill prompt: ${subskillName}`);
-    }
-    markSubskillPromptLoaded(subskillName);
-    const fullPrompt = stripFrontmatter(skill.content);
-    const safeOffset = Math.min(Math.max(Number.isFinite(offset) ? Math.floor(offset ?? 0) : 0, 0), fullPrompt.length);
+function readChunkedContent(content, offset, limit, continuation) {
+    const safeOffset = Math.min(Math.max(Number.isFinite(offset) ? Math.floor(offset ?? 0) : 0, 0), content.length);
     const requestedLimit = Number.isFinite(limit) && limit !== undefined
         ? Math.max(Math.floor(limit), 1)
         : null;
-    const defaultChunkLimit = fullPrompt.length > DEFAULT_SUBSKILL_PROMPT_CHUNK_CHARS
+    const defaultChunkLimit = content.length > DEFAULT_SUBSKILL_PROMPT_CHUNK_CHARS
         ? DEFAULT_SUBSKILL_PROMPT_CHUNK_CHARS
         : null;
     const safeLimit = requestedLimit === null
         ? defaultChunkLimit
         : Math.min(requestedLimit, MAX_SUBSKILL_PROMPT_CHUNK_CHARS);
-    const prompt = safeLimit === null
-        ? fullPrompt
-        : fullPrompt.slice(safeOffset, safeOffset + safeLimit);
+    const chunk = safeLimit === null
+        ? content
+        : content.slice(safeOffset, safeOffset + safeLimit);
     const nextOffset = safeLimit === null
         ? null
-        : Math.min(safeOffset + safeLimit, fullPrompt.length);
-    const hasMore = nextOffset !== null && nextOffset < fullPrompt.length;
-    const chunkCount = safeLimit === null
-        ? 1
-        : Math.max(Math.ceil(fullPrompt.length / safeLimit), 1);
+        : Math.min(safeOffset + safeLimit, content.length);
+    const hasMore = nextOffset !== null && nextOffset < content.length;
+    const chunkCount = safeLimit === null ? 1 : Math.max(Math.ceil(content.length / safeLimit), 1);
     const chunkIndex = safeLimit === null
         ? 1
         : Math.min(Math.floor(safeOffset / safeLimit) + 1, chunkCount);
     return {
-        name: skill.name,
-        description: skill.description,
-        visibility: skill.visibility,
-        prompt,
-        promptLength: fullPrompt.length,
+        chunk,
+        contentLength: content.length,
         offset: safeOffset,
         limit: safeLimit ?? undefined,
         hasMore,
         nextOffset: hasMore ? nextOffset : null,
         chunkIndex,
         chunkCount,
-        chunkingInstructions: hasMore
-            ? `Continue this same prompt load with get_subskill_prompt({ subskillName: "${skill.name}", offset: ${nextOffset}, limit: ${safeLimit} }) until hasMore is false. Treat all chunks as one prompt load; do not use saved local tool-output files or machine-specific paths.`
+        chunkingInstructions: hasMore && nextOffset !== null && safeLimit !== null && continuation
+            ? continuation(nextOffset, safeLimit)
             : undefined,
     };
 }
+export function getSubskillPrompt(subskillName, offset, limit) {
+    const skill = getSkillByName(subskillName);
+    if (!skill) {
+        throw new Error(`Unknown subskill prompt: ${subskillName}`);
+    }
+    markSubskillPromptLoaded(subskillName);
+    const fullPrompt = stripFrontmatter(skill.content);
+    const chunked = readChunkedContent(fullPrompt, offset, limit, (nextOffset, safeLimit) => `Continue this same prompt load with get_subskill_prompt({ subskillName: "${skill.name}", offset: ${nextOffset}, limit: ${safeLimit} }) until hasMore is false. Treat all chunks as one prompt load; do not use saved local tool-output files or machine-specific paths.`);
+    return {
+        name: skill.name,
+        description: skill.description,
+        visibility: skill.visibility,
+        prompt: chunked.chunk,
+        promptLength: chunked.contentLength,
+        offset: chunked.offset,
+        limit: chunked.limit,
+        hasMore: chunked.hasMore,
+        nextOffset: chunked.nextOffset,
+        chunkIndex: chunked.chunkIndex,
+        chunkCount: chunked.chunkCount,
+        chunkingInstructions: chunked.chunkingInstructions,
+    };
+}
+function resolveSubskillAssetPath(subskillName, assetPath) {
+    const cleanAssetPath = assetPath.replace(/\\/g, "/").trim();
+    if (cleanAssetPath === "" ||
+        cleanAssetPath.startsWith("/") ||
+        cleanAssetPath.split("/").includes("..")) {
+        throw new Error(`Invalid subskill asset path: ${assetPath}`);
+    }
+    const skillRoot = path.resolve(resolveSkillsDir(), subskillName);
+    const resolved = path.resolve(skillRoot, cleanAssetPath);
+    const relative = path.relative(skillRoot, resolved);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error(`Invalid subskill asset path: ${assetPath}`);
+    }
+    return { cleanAssetPath, resolved };
+}
+export function getSubskillAsset(subskillName, assetPath, offset, limit) {
+    if (!getSkillByName(subskillName)) {
+        throw new Error(`Unknown subskill prompt: ${subskillName}`);
+    }
+    const { cleanAssetPath, resolved } = resolveSubskillAssetPath(subskillName, assetPath);
+    if (!fs.existsSync(resolved) || !fs.statSync(resolved).isFile()) {
+        throw new Error(`Unknown subskill asset: ${subskillName}/${cleanAssetPath}`);
+    }
+    const content = fs.readFileSync(resolved, "utf8");
+    const chunked = readChunkedContent(content, offset, limit, (nextOffset, safeLimit) => `Continue this same asset load with get_subskill_asset({ subskillName: "${subskillName}", assetPath: "${cleanAssetPath}", offset: ${nextOffset}, limit: ${safeLimit} }) until hasMore is false. Treat all chunks as one asset load; do not use saved local tool-output files or machine-specific paths.`);
+    return {
+        subskillName,
+        assetPath: cleanAssetPath,
+        content: chunked.chunk,
+        contentLength: chunked.contentLength,
+        offset: chunked.offset,
+        limit: chunked.limit,
+        hasMore: chunked.hasMore,
+        nextOffset: chunked.nextOffset,
+        chunkIndex: chunked.chunkIndex,
+        chunkCount: chunked.chunkCount,
+        chunkingInstructions: chunked.chunkingInstructions,
+    };
+}
 export function completeSenderResearch(input) {
     return markSenderResearchCompleted(input);
 }

package/dist/tools/rubrics.d.ts

@@ -34,6 +34,7 @@ type WaitForRubricResultsInput = {
     targetCount?: number;
     timeoutMs?: number;
     intervalMs?: number;
+    includeRows?: boolean;
 };
 type WorkflowTableStats = {
     tableId: string;
@@ -101,6 +102,7 @@ export declare const rubricToolDefinitions: ({
             targetCount?: undefined;
             timeoutMs?: undefined;
             intervalMs?: undefined;
+            includeRows?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -132,6 +134,7 @@ export declare const rubricToolDefinitions: ({
             targetCount?: undefined;
             timeoutMs?: undefined;
             intervalMs?: undefined;
+            includeRows?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -188,6 +191,7 @@ export declare const rubricToolDefinitions: ({
             targetCount?: undefined;
             timeoutMs?: undefined;
             intervalMs?: undefined;
+            includeRows?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -244,6 +248,7 @@ export declare const rubricToolDefinitions: ({
             targetCount?: undefined;
             timeoutMs?: undefined;
             intervalMs?: undefined;
+            includeRows?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -302,6 +307,7 @@ export declare const rubricToolDefinitions: ({
             targetCount?: undefined;
             timeoutMs?: undefined;
             intervalMs?: undefined;
+            includeRows?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -330,6 +336,7 @@ export declare const rubricToolDefinitions: ({
             targetCount?: undefined;
             timeoutMs?: undefined;
             intervalMs?: undefined;
+            includeRows?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -358,6 +365,7 @@ export declare const rubricToolDefinitions: ({
             targetCount?: undefined;
             timeoutMs?: undefined;
             intervalMs?: undefined;
+            includeRows?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -388,6 +396,10 @@ export declare const rubricToolDefinitions: ({
                 type: string;
                 description: string;
             };
+            includeRows: {
+                type: string;
+                description: string;
+            };
             leadScoringRubrics?: undefined;
             requiredCheckNames?: undefined;
             rubric?: undefined;
@@ -466,6 +478,8 @@ export declare function checkRubric(input: CheckRubricInput): Promise<{
     tableId: string;
 }>;
 export declare function waitForRubricResults(input: WaitForRubricResultsInput): Promise<{
+    stats: WorkflowTableStats;
+    rows?: import("./rows.js").LightweightRow[] | undefined;
     ready: boolean;
     attempts: number;
     elapsedMs: number;
@@ -476,8 +490,6 @@ export declare function waitForRubricResults(input: WaitForRubricResultsInput):
         percent: number;
         targetCount: number;
     };
-    rows: import("./rows.js").LightweightRow[];
-    stats: WorkflowTableStats;
     reason?: undefined;
 } | {
     ready: boolean;
@@ -492,6 +504,5 @@ export declare function waitForRubricResults(input: WaitForRubricResultsInput):
         targetCount: number;
     };
     stats: WorkflowTableStats | null;
-    rows?: undefined;
 }>;
 export {};

package/dist/tools/rubrics.js

@@ -356,6 +356,10 @@ export const rubricToolDefinitions = [
                     type: "number",
                     description: `Polling interval in ms (default ${DEFAULT_INTERVAL_MS}).`,
                 },
+                includeRows: {
+                    type: "boolean",
+                    description: "Whether to include minimal row snapshots in the response. Default true for backwards compatibility; pass false for stats-only polling in long autonomous flows.",
+                },
             },
             required: [],
             additionalProperties: false,
@@ -619,6 +623,7 @@ export async function waitForRubricResults(input) {
     const timeoutMs = Math.max(5000, input.timeoutMs ?? DEFAULT_TIMEOUT_MS);
     const intervalMs = Math.max(500, input.intervalMs ?? DEFAULT_INTERVAL_MS);
     const targetCount = resolveMaxProspects(input.targetCount);
+    const includeRows = input.includeRows !== false;
     let tableId = input.tableId;
     if (!tableId && input.campaignOfferId) {
         const campaign = await fetchCampaignOffer(input.campaignOfferId);
@@ -640,10 +645,11 @@ export async function waitForRubricResults(input) {
         if (completed >= effectiveTarget) {
             const passed = stats.passRate?.passed ?? 0;
             const percent = completed > 0 ? Math.round((passed / completed) * 100) : 0;
-            // Fetch current row states so caller sees per-row enrich/ICP status
-            const rowSnapshot = await getTableRowsMinimal(tableId, {
-                limit: effectiveTarget,
-            });
+            const rowSnapshot = includeRows
+                ? await getTableRowsMinimal(tableId, {
+                    limit: effectiveTarget,
+                })
+                : null;
             return {
                 ready: true,
                 attempts,
@@ -655,7 +661,7 @@ export async function waitForRubricResults(input) {
                     percent,
                     targetCount: effectiveTarget,
                 },
-                rows: rowSnapshot.rows,
+                ...(rowSnapshot ? { rows: rowSnapshot.rows } : {}),
                 stats,
             };
         }

package/package.json

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

package/skills/create-campaign/SKILL.md

@@ -8,6 +8,7 @@ allowed-tools:
   - mcp__sellable__wait_for_cli_login
   - mcp__sellable__bootstrap_create_campaign
   - mcp__sellable__get_subskill_prompt
+  - mcp__sellable__get_subskill_asset
   - mcp__sellable__search_subskill_prompts
   - mcp__sellable__get_provider_prompt
   - mcp__sellable__get_message_prompt
@@ -449,19 +450,24 @@ updates.
 
 1. Load canonical prompt via
    `mcp__sellable__get_subskill_prompt({ subskillName: "create-campaign-v2" })`.
-2. Follow that prompt exactly.
-3. For message generation, load the full `generate-messages` prompt in the
+2. Load the canonical workflow config via
+   `mcp__sellable__get_subskill_asset({ subskillName: "create-campaign-v2", assetPath: "core/flow.v2.json" })`.
+   Treat the returned JSON as the active state machine. Do not read repo-local
+   copies of this file; packaged Claude Code and Codex runs must use the MCP
+   asset loader so they share the same config.
+3. Follow that prompt and workflow config exactly.
+4. For message generation, load the full `generate-messages` prompt in the
    same run with chunked
    `mcp__sellable__get_subskill_prompt({ subskillName: "generate-messages", offset, limit })`
    calls until `hasMore` is false. Do not synthesize
    `message-validation.md` from the brief, lead review, or general knowledge.
-4. Treat message quality as the gate before minting. Do not create a campaign,
+5. Treat message quality as the gate before minting. Do not create a campaign,
    show a commit gate, or mint anything until `message-validation.md` proves
    the full generate-messages workflow ran and `message-review.md` recommends
    `approve-message` against the gold-standard rules.
-5. Do not create or mutate the live campaign until the approval gate returns
+6. Do not create or mutate the live campaign until the approval gate returns
    `approve`.
-6. Do not ask the user to run another command.
+7. Do not ask the user to run another command.
 
 ## Fallback
 

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

@@ -74,6 +74,11 @@ Validated draft directory:
 - Net-new runs start at `bootstrap` -> `brief-interview` in
   `core/flow.v2.json`. Do not start at `validate-artifacts` unless resuming a
   compatibility run where all upstream artifacts already exist.
+- Load `core/flow.v2.json` through
+  `get_subskill_asset({ subskillName: "create-campaign-v2", assetPath: "core/flow.v2.json" })`
+  at the start of the run and treat the returned JSON as the active state
+  machine. Do not read repo-local config files; packaged Claude Code and Codex
+  runs must use the MCP asset loader so they execute the same workflow.
 - Use the host-native structured question gate whenever it is exposed. In
   Claude Code, this is `AskUserQuestion`. In Codex, this is
   `request_user_input` (enabled in Default mode by
@@ -410,22 +415,23 @@ should test for this campaign. Those can run in parallel and usually take
   `approval-packet.md`.
 - Run the dependency chain as a DAG: `create-campaign-brief` -> `find leads`;
   once `lead-review.md` and `lead-sample.json` exist, run `filter leads` and
-  `message generation` as parallel branches from the same basis (`brief.md`,
-  `lead-review.md`, `lead-sample.json`). Approval waits for both
-  `lead-filter.md` and `message-validation.md`, then reconciles that the
-  selected message basis rows still pass the final filter.
-- Parallel means real parallel execution, not optimistic progress copy. After
-  lead review, if the host exposes Task/subagent workers and host policy allows
-  them for this user request, launch two disjoint workers: one owns
-  `lead-filter.md` and optional `rubric.json`; the other owns the user-facing
-  message generation branch and may write `message-prep.md`,
-  `message-validation.md`, and `message-review.md`. If only parallel tool
-  batching is available, batch independent tool reads/lookups only. If real
-  parallel execution is not available or not allowed, run the same DAG
-  sequentially and use honest copy: `I’ll tighten the filter first, then draft
-the message from the same sample.` Never say `kicking off two workstreams`,
-  `in parallel`, or `background` unless parallel branches were actually
-  launched.
+  `message generation` from the same basis (`brief.md`, `lead-review.md`,
+  `lead-sample.json`). Approval waits for both `lead-filter.md` and
+  `message-validation.md`, then reconciles that the selected message basis rows
+  still pass the final filter.
+- Parallel means real parallel execution, not optimistic progress copy. Prefer
+  product-native parallelism that works in both Claude Code and Codex:
+  independent MCP/tool calls in the same model turn, or dedicated Sellable MCP
+  tools that perform their own server-side `Promise.all` fan-out. Host subagents
+  are optional acceleration only: use Claude Task/subagents or Codex subagents
+  only when the host exposes them, policy allows them, and the user explicitly
+  asked for agent fan-out. A normal `$sellable:create-campaign` invocation is
+  not an explicit request for Codex subagents. If only parallel tool batching is
+  available, batch independent tool reads/lookups only. If real parallel
+  execution is not available or not allowed, run the same DAG sequentially and
+  use honest copy: `I’ll tighten the filter first, then draft the message from
+the same sample.` Never say `kicking off two workstreams`, `in parallel`, or
+  `background` unless parallel branches were actually launched.
 - Never run a downstream stage until the active `flow.v2.json` step's
   `requiredArtifacts` exist.
 - Never call a tool outside the active step's `allowedTools`, and never call a
@@ -524,17 +530,25 @@ lists as optional, not required. The three visible options are exactly:
 
 1. `Find people for me (recommended if you don't already have your own list)`
 2. `I have a CSV of LinkedIn profiles`
-3. `I have a CSV of company domains`
+3. `I have a company/domain list to target`
+
+Do not expose provider or implementation paths as the user's lead-source
+choices. Never label the structured options as `engagers`, `titles`,
+`Signals`, `Sales Nav`, `Prospeo`, `search LinkedIn posts`, or similar. Those
+are internal scouting methods for the `Find people for me` path, not choices a
+first-time user should have to understand.
 
 Keep `Other / custom` available for freeform answers such as a pasted list,
 an existing Sellable lead list, or another source idea. Do not put existing
 Sellable lead lists in the main three-option first batch; support them through
-custom/freeform input. If the user pastes up to 100 LinkedIn profile URLs or
-company domains, normalize the paste into a temporary local CSV and continue
-through the matching CSV preview path. Mixed, ambiguous, malformed, or oversized
-pastes should ask for a real CSV file instead of guessing. Uploaded CSV support
-is larger than paste support: LinkedIn profile CSVs can contain up to 7,500
-rows; domain CSVs can contain up to 7,500 rows but only 1,000 unique domains.
+custom/freeform input. If the user chooses the company/domain option, ask in
+normal chat whether they have a CSV, pasted domains, or pasted company names.
+If the user pastes up to 100 LinkedIn profile URLs or company domains,
+normalize the paste into a temporary local CSV and continue through the
+matching CSV preview path. Mixed, ambiguous, malformed, or oversized pastes
+should ask for a real CSV file instead of guessing. Uploaded CSV support is
+larger than paste support: LinkedIn profile CSVs can contain up to 7,500 rows;
+domain CSVs can contain up to 7,500 rows but only 1,000 unique domains.
 
 Avoid internal wording like `Which proof points should the message be allowed
 to lean on?` because it describes the artifact, not the founder decision.
@@ -573,7 +587,10 @@ Required behavior:
 - do not mutate DB-backed campaign state
 - run a real parallel source-angle scout when the source is not supplied and at
   least two viable source angles exist. Treat source scouting as independent
-  branches, then compare the outputs in `lead-review.md`.
+  branches, then compare the outputs in `lead-review.md`. If the realistic
+  source set is Signals + Sales Nav, run both. If it is Signals + Prospeo, run
+  both. If all three are credible, run all three when the host/runtime supports
+  it.
   - Branch A: Signals / active LinkedIn posts. Search relevant keyword lanes,
     review finalist posts, fetch top-post engagers, and estimate warm-fit
     volume.
@@ -589,7 +606,7 @@ Required behavior:
     lanes and fetch top-post engagers in parallel when tool batching allows it.
     For Sales Nav-first or Prospeo/account-first campaigns, run multiple preview
     lanes for that provider in parallel and use Signals only as a warmth/quality
-    check when relevant
+    check when relevant.
 - after every Sales Nav preview, validate that filters actually applied before
   using the lane in `lead-review.md`: `searchUrl` should include filters, the
   first page should match the intended roles/companies, and the result count
@@ -606,6 +623,16 @@ Required behavior:
   keyword lanes; it does not mean 492 prospects. The source decision must name
   the actual posts we would use, show why they won, and estimate usable engagers
   from those posts after headline/sample filtering
+- Signals viability is based on estimated ICP-fit reachable engagers, not raw
+  post count and not whether it beats Sales Nav scale. If 5-8 selected posts can
+  plausibly produce ~150+ ICP-fit warm prospects before final filtering, keep
+  Signals as a viable focused option. If stricter cleanup likely reduces that to
+  ~100 usable prospects, say so plainly instead of discarding it.
+- When Signals is viable-but-smaller and Sales Nav or Prospeo is more scalable,
+  the user-facing lead review must present the choice: Signals for a warmer,
+  smaller, higher-reply-upside first batch versus Sales Nav/Prospeo for broader
+  scale. Recommend the source you believe should win, often Sales Nav when scale
+  matters, but keep the smaller Signals lane available as a real option.
 - user-facing source logic must use numbers, not vibes. Never write a percentage
   such as `73% match` without the numerator, denominator, and sample basis, e.g.
   `8 of 11 sampled engagers fit the ICP (73%)`. If the sample is small, say it is
@@ -621,9 +648,10 @@ usable leads`.
   last 30 days, prefer the last 7-14 days when quality is comparable, and call
   out any older post as a deliberate tradeoff. Do not hide post age inside the
   raw search count
-- default source quality target is 300-500+ likely usable leads; accept
-  150-300 only for an explicit beta/design-partner motion and name that
-  volume tradeoff in `lead-review.md` and the approval packet
+- default source quality target is 300-500+ likely usable leads for scalable
+  outbound; accept ~150+ likely ICP-fit warm prospects as viable for a focused
+  Signals-first campaign or first review batch. Name the volume tradeoff in
+  `lead-review.md` and the approval packet rather than forcing a discard.
 - if `lead-source-intake.json` is present, read `sourceType`,
   `sourceInputMode`, file path or existing lead-list ID, selected columns,
   confirmation token, normalized counts, and any preview-created

package/skills/create-campaign-v2/core/flow.v2.json

@@ -64,6 +64,13 @@
           "requiredValues": {
             "subskillName": "create-campaign-v2"
           }
+        },
+        {
+          "tool": "get_subskill_asset",
+          "requiredValues": {
+            "subskillName": "create-campaign-v2",
+            "assetPath": "core/flow.v2.json"
+          }
         }
       ],
       "requiredArtifacts": [],
@@ -73,6 +80,7 @@
         "get_auth_status",
         "get_active_workspace",
         "get_subskill_prompt",
+        "get_subskill_asset",
         "AskUserQuestion",
         "request_user_input"
       ],
@@ -159,8 +167,17 @@
           "options": [
             "Find people for me (recommended if you don't already have your own list)",
             "I have a CSV of LinkedIn profiles",
-            "I have a CSV of company domains"
+            "I have a company/domain list to target"
           ],
+          "forbiddenOptionLabels": [
+            "engagers",
+            "titles",
+            "Signals",
+            "Sales Nav",
+            "Prospeo",
+            "search LinkedIn posts"
+          ],
+          "forbiddenOptionLabelReason": "Provider/source mechanics are internal to the 'Find people for me' path; first-time users should choose the job they need done, not the scouting provider.",
           "customInput": true,
           "lastQuestionInFirstStrategyBatch": true
         }
@@ -169,6 +186,7 @@
       "producesArtifacts": ["brief-v1.md", "brief.md"],
       "allowedTools": [
         "get_subskill_prompt",
+        "get_subskill_asset",
         "get_auth_status",
         "get_active_workspace",
         "list_senders",
@@ -301,7 +319,7 @@
           "action": "run_subskill",
           "target": "find-leads",
           "mode": "campaignless-preview",
-          "sourceScoutRule": "When source is not user-supplied and at least two viable source angles exist, scout independent source angles in parallel when host/tooling permits: Signals active-post branch, Sales Nav title/company branch, and Prospeo/domain branch only when relevant. If real parallel execution is unavailable, run the same scouts sequentially and do not claim parallel execution. Compare outputs by raw volume, n/N sampled fit, estimated good-fit range, expected reply range, and tradeoff."
+          "sourceScoutRule": "When source is not user-supplied and at least two viable source angles exist, scout independent source angles with product-native parallelism when host/tooling permits: independent MCP/tool calls in the same model turn or dedicated Sellable MCP tools that perform server-side fan-out. Signals active-post branch + Sales Nav title/company branch, Signals + Prospeo when domains/accounts are relevant, or all three when credible. Do not rely on Codex subagents for a normal $sellable:create-campaign invocation; use host subagents only when the user explicitly asked for agent fan-out. If real parallel execution is unavailable, run the same scouts sequentially and do not claim parallel execution. Compare outputs by raw volume, n/N sampled fit, estimated good-fit range, expected reply range, and tradeoff. Keep Signals as viable when selected posts can produce ~150+ ICP-fit warm prospects before final filtering, even if Sales Nav is more scalable; when both are viable, present the choice and recommend the stronger default."
         },
         {
           "action": "write_artifacts",
@@ -312,6 +330,7 @@
       "producesArtifacts": ["lead-review.md", "lead-sample.json"],
       "allowedTools": [
         "get_subskill_prompt",
+        "get_subskill_asset",
         "get_provider_prompt",
         "lookup_sales_nav_filter",
         "search_sales_nav",
@@ -415,7 +434,7 @@
             "parallel only if real parallel branches were launched"
           ],
           "timeEstimate": "~2-3 min",
-          "chatRenderRule": "If real parallel workers/branches were actually launched, say: 'I’m kicking off two workstreams now' and list 'Tighten the fit filter' and 'Message generation'. If not, do not mention parallel/background work; say: 'I’ll tighten the filter first, then run message generation from the same approved brief and sample leads.' Never claim parallelism unless the host actually started parallel execution. User-facing stage name is message generation; message-validation.md is only the internal artifact."
+          "chatRenderRule": "If real parallel MCP/tool branches or explicitly requested host subagents were actually launched, say: 'I’m kicking off two workstreams now' and list 'Tighten the fit filter' and 'Message generation'. If not, do not mention parallel/background work; say: 'I’ll tighten the filter first, then run message generation from the same approved brief and sample leads.' Never claim parallelism unless parallel execution actually started. A normal $sellable:create-campaign invocation is not an explicit request for Codex subagents. User-facing stage name is message generation; message-validation.md is only the internal artifact."
         },
         {
           "action": "ask_continue_revise_or_confirm_only_if_needed",
@@ -503,6 +522,7 @@
       "optionalProducesArtifacts": ["rubric.json"],
       "allowedTools": [
         "get_subskill_prompt",
+        "get_subskill_asset",
         "AskUserQuestion",
         "request_user_input"
       ],
@@ -554,6 +574,7 @@
       "producesArtifacts": ["message-validation.md"],
       "allowedTools": [
         "get_subskill_prompt",
+        "get_subskill_asset",
         "AskUserQuestion",
         "request_user_input"
       ],
@@ -1015,6 +1036,11 @@
         {
           "action": "load_auto_execute_config",
           "source": "core/auto-execute.yaml",
+          "tool": "get_subskill_asset",
+          "requiredValues": {
+            "subskillName": "create-campaign-v2",
+            "assetPath": "core/auto-execute.yaml"
+          },
           "loadOnce": true
         },
         {
@@ -1022,7 +1048,11 @@
           "target": "85-02"
         }
       ],
-      "allowedTools": ["AskUserQuestion", "request_user_input"],
+      "allowedTools": [
+        "get_subskill_asset",
+        "AskUserQuestion",
+        "request_user_input"
+      ],
       "transitions": {
         "autonomous_tail_started": "auto-execute-leads"
       }
@@ -1105,6 +1135,7 @@
         }
       ],
       "allowedTools": [
+        "get_subskill_asset",
         "import_leads",
         "wait_for_lead_list_ready",
         "confirm_lead_list",
@@ -1153,11 +1184,14 @@
           "tool": "wait_for_rubric_results",
           "requiredFields": ["targetCount"],
           "targetCountSource": "stats.totalRows_or_imported_batch_count",
+          "requiredValues": {
+            "includeRows": false
+          },
           "note": "default targetCount=25 returns ready=true after first 25 completions even when cohort is still pending; always pass cohortSize explicitly (see references/sample-validation-loop.md §Known Tool Behaviors #3)",
-          "readVia": "subagent",
+          "readVia": "stats_only_tool_result",
           "extractFields": ["ready", "passRate.completed", "stats"],
           "doNotRetain": "rows_payload",
-          "contextBloatNote": "25 rows ≈ 67KB; 100 rows ≈ 268KB; use subagent extraction (see references/sample-validation-loop.md §Known Tool Behaviors #2)"
+          "contextBloatNote": "Pass includeRows=false so the MCP tool returns stats only; 25 rows ≈ 67KB and 100 rows ≈ 268KB when row payloads are retained (see references/sample-validation-loop.md §Known Tool Behaviors #2)."
         },
         {
           "action": "compute_projected_pass",
@@ -1176,6 +1210,7 @@
         }
       ],
       "allowedTools": [
+        "get_subskill_asset",
         "get_rows_minimal",
         "wait_for_campaign_table_ready",
         "wait_for_rubric_results",
@@ -1287,6 +1322,7 @@
         }
       ],
       "allowedTools": [
+        "get_subskill_asset",
         "get_rows_minimal",
         "queue_cells",
         "wait_for_campaign_table_ready",
@@ -1345,6 +1381,7 @@
         }
       ],
       "allowedTools": [
+        "get_subskill_asset",
         "attach_recommended_sequence",
         "AskUserQuestion",
         "request_user_input"

package/skills/create-campaign-v2/references/sample-validation-loop.md

@@ -56,7 +56,7 @@ auto-revise leads.
      accidentally stop early
      (see §Known Tool Behaviors #3)
 
-7. read the result via a subagent; extract ONLY:
+7. call `wait_for_rubric_results` with `includeRows=false`; extract ONLY:
    - ready: boolean
    - passRate.completed: number
    - stats: object
@@ -110,16 +110,11 @@ Observed: default response includes `carryData.Post Content` with
 whole LinkedIn post bodies. ~67KB per 25 rows. ~268KB per 100 rows.
 Retaining the full payload across tail turns blows Opus context.
 
-Workaround (short-term): invoke `wait_for_rubric_results` inside a
-subagent turn and extract ONLY `ready`, `passRate.completed`, and
-`stats`. Never put the raw rows payload back into the tail's own
-context. Prefer `get_rows_minimal` (not `get_rows`) when row-level
+Workaround: pass `includeRows=false` so `wait_for_rubric_results`
+returns stats only. Never put raw rows payload back into the tail's
+own context. Prefer `get_rows_minimal` (not `get_rows`) when row-level
 inspection is required, and strip `carryData` before retention.
 
-Workaround (long-term): add a `includeRows=false` / stats-only mode
-to `wait_for_rubric_results` at the MCP tool level. Tracked as a
-backlog item; until then the subagent-read pattern is the contract.
-
 ### 3. `wait_for_rubric_results.targetCount` defaults to 25
 
 Observed: default `targetCount=25` returns `ready=true` after the first 25

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

@@ -104,8 +104,11 @@ Message` column's http_request writes those cells via the cascade.
   generation is a credit-spend decision and must happen after the user
   has reviewed the sample.
 
-Load `core/auto-execute.yaml` exactly once at the start of Step 13. All
-subsequent steps read the already-parsed config. Do not re-load mid-run.
+Load `core/auto-execute.yaml` exactly once at the start of Step 13 through
+`get_subskill_asset({ subskillName: "create-campaign-v2", assetPath: "core/auto-execute.yaml" })`.
+All subsequent steps read the already-parsed config. Do not re-load mid-run,
+and do not read repo-local config files; packaged Claude Code and Codex runs
+must use the MCP asset loader.
 Load each subskill prompt (`create-campaign-v2`, `research-sender`,
 `generate-messages`) at most once per run. A multi-call chunk sequence counts
 as one load. If a tool result already told you to load a prompt, load all
@@ -155,8 +158,9 @@ atomic mint).
 > for the lead-list table by name or skip the `mode: "add"` path; do
 > not pass the campaign-table id as `sourceLeadListId`.
 
-1. Load `core/auto-execute.yaml`. Capture `import.importLimit`,
-   `sample.sampleSize`, `sample.minProjectedPass`,
+1. Load `core/auto-execute.yaml` through
+   `get_subskill_asset({ subskillName: "create-campaign-v2", assetPath: "core/auto-execute.yaml" })`.
+   Capture `import.importLimit`, `sample.sampleSize`, `sample.minProjectedPass`,
    `sample.maxRevisionRounds`, `messaging.tokenContract`,
    `messaging.critique.enabled`, `handoff.autoStart`,
    `handoff.orientation`, `retry.sameToolSameError`,
@@ -443,4 +447,12 @@ runs.
 | `core/auto-execute.yaml`                   | Start of Step 13, load once; all tail steps read parsed values         |
 | `core/auto-execute.README.md`              | When tuning `auto-execute.yaml` knobs or reviewing threshold-trip logs |
 
+Load every file in this table with:
+
+```text
+get_subskill_asset({ subskillName: "create-campaign-v2", assetPath: "<file>" })
+```
+
+Do not use local filesystem reads for these files in customer runs.
+
 </references_index>

package/skills/find-leads/SKILL.md

@@ -235,6 +235,11 @@ Use the existing provider tools to run a small, directional probe:
 
 If the first probe is weak or noisy and enough context exists, try 1-2 alternate hypotheses before returning.
 If the first probe has good quality but insufficient scale, iterate 1-2 times to widen intelligently before returning.
+When two or more source angles are viable, run the provider probes in real
+parallel when the host/runtime allows it. Examples: Signals + Sales Nav,
+Signals + Prospeo, or Sales Nav + Prospeo. If the host cannot run them in
+parallel, run the same probes sequentially and do not claim they ran in
+parallel.
 
 Treat refinement as a measured loop:
 
@@ -262,10 +267,23 @@ Use first when the value is in conversation opportunity, competitor engagers, co
 - Favor ICP-fit conversation density over raw post volume.
 - Capture counts, false-positive patterns, and notable examples.
 - If Signals is materially in the running, do not stop at post-level quality alone.
-- Pick 1-2 promising posts, then call `fetch_post_engagers` on those posts.
+- Pick enough promising posts to estimate campaign viability. Start with 1-3
+  strong posts for a spot check; if the sampled pass rate is good but the
+  projected pool is below target, expand to 5-8 selected posts before
+  discarding Signals.
 - Sample a representative first page only, scoring the first 25-40 engagers across the chosen posts against a rough yes/no headline rubric or `headlineICPCriteria`.
 - Use headline and display-name cues only for the spot-check sample; do not enrich people during this phase.
 - Base `estimatedReachableLeads` on the sampled engager pass rate, not only on a guessed discount from post themes.
+- A Signals lane with ~150+ estimated ICP-fit reachable engagers from selected
+  posts is viable for a focused warm campaign, even if Sales Nav is more
+  scalable. Do not discard that lane solely for being smaller. If post-level
+  filtering likely reduces 150 good fits to ~100 after stricter cleanup, say so
+  plainly and treat it as a viable-but-smaller option.
+- When Signals and Sales Nav/Prospeo are both viable, present the tradeoff and
+  ask for the user's source preference if the decision changes campaign
+  strategy: Signals = warmer, smaller, higher reply upside; Sales Nav/Prospeo =
+  more scalable, usually colder or less signal-rich. Recommend the source you
+  believe is better, but keep the viable alternate as a real option.
 - If you cannot fetch engagers in the current runtime, say the estimate is inferred and lower confidence.
 - If Signals is too sparse, too noisy, or clearly below campaign scale after the spot check, fall back to `Sales Nav` rather than forcing a weak conversation-led lane.
 

package/skills/generate-messages/SKILL.md

@@ -2263,21 +2263,27 @@ borrow the closest message shape from
 
 When crafting messages for multiple rows (e.g., "craft rows 1-5"):
 
-**CRITICAL: Use parallel subagents for efficiency.**
+**CRITICAL: Use real parallelism only when the host explicitly supports it for
+this run. Prefer product-native MCP/tool parallelism that works in both Claude
+Code and Codex; host subagents are optional acceleration only when the user
+explicitly asked for agent fan-out.**
 
 1. Load campaign examples, calibration notes, and bounded copy from the brief first.
 2. Call `get_message_prompt()` once to get the fallback REPLY framework and QA checks
-3. Spawn parallel subagents using the `Task` tool with explicit `model: "opus"` and `subagent_type: "general-purpose"` (never omit model):
+3. If the user explicitly asked for agent fan-out and the host exposes subagents,
+   spawn parallel workers with explicit model/config. Otherwise batch independent
+   MCP/tool reads where available or run rows sequentially with honest progress
+   copy. Do not claim subagents or background work unless they actually started.
 
 ```
-For each row (1-5), launch a Task subagent:
+For each row (1-5), launch a worker only when allowed:
 - subagent_type: "general-purpose"
 - model: "opus"
 - prompt: Include campaign context, sender info, row data, gold-standard message examples when present, and fallback REPLY framework
 - Do NOT use run_in_background (avoids notification spam)
 ```
 
-4. Each subagent:
+4. Each worker or sequential row pass:
 
    - Researches the prospect (WebSearch, LinkedIn tools)
    - Crafts message by following the campaign's gold-standard pattern first
@@ -2285,7 +2291,7 @@ For each row (1-5), launch a Task subagent:
    - Uses the fallback REPLY framework only as structure and QA support
    - Returns the draft + research notes (do NOT save)
 
-5. Wait for all subagents to complete
+5. Wait for all workers to complete, or finish the sequential row pass
 6. Auto-save drafts for rows where the message cell is empty (announce "Draft saved (not approved)")
 7. Show summary:
 
@@ -2303,9 +2309,9 @@ Approve all for sending?
 - Review individually first
 ```
 
-### Subagent Prompt Template
+### Optional Worker Prompt Template
 
-When spawning craft subagents, include:
+When spawning craft workers, include:
 
 ```
 Craft a personalized LinkedIn message for this prospect using the campaign's
@@ -2371,7 +2377,9 @@ research → condense → 10 angle agents in parallel → finalizer combines bes
    - use the strongest safe proof
    - make the CTA a useful next step, not a vague meeting ask
 5. Build a condensed angle brief (~1.5k tokens) from research + sender info
-6. Fan out 10 angle agents (model: "sonnet", run_in_background: true):
+6. If explicit host subagent fan-out is available, fan out 10 angle workers
+   (model: "sonnet", no delayed/background notifications). Otherwise explore
+   a smaller bounded set of angles sequentially and do not claim parallelism:
    - Each gets the condensed brief + their angle instruction (~2k tokens per agent)
    - DO NOT pass the full fallback REPLY framework to angle agents, only the brief
 7. After all 10 return, act as the Finalizer:
@@ -2384,7 +2392,7 @@ research → condense → 10 angle agents in parallel → finalizer combines bes
 8. Return: { success: true, message: "...", research: [...], anglesExplored: 10 }
 ```
 
-**IMPORTANT:** Load `.sellable/configs/writing/outbound.md`, `styleguide-core.md`, and `.sellable/insights/cross-skill.md` ONCE in the lead agent, then pass **condensed** versions to subagents. Don't pass full file contents to every subagent — that wastes context and causes overflow.
+**IMPORTANT:** Load `.sellable/configs/writing/outbound.md`, `styleguide-core.md`, and `.sellable/insights/cross-skill.md` ONCE in the lead agent, then pass **condensed** versions to any workers. Don't pass full file contents to every worker — that wastes context and causes overflow.
 
 ## Batch Approval
 

package/skills/research-prospect/SKILL.md

@@ -33,9 +33,12 @@ Provide as many as available. Use `"Unknown"` when missing.
 
 Choose backend once:
 
-1. If `Task` is available: use Task subagents in parallel.
-2. Else if `multi_tool_use.parallel` is available: batch independent tool calls via `multi_tool_use.parallel`.
-3. Else: run units sequentially.
+1. If product-native MCP/tool parallel calls are available: batch independent
+   retrieval units in one turn.
+2. If the user explicitly asked for agent fan-out and `Task` is available: use
+   Task subagents in parallel.
+3. Else if `multi_tool_use.parallel` is available: batch independent tool calls via `multi_tool_use.parallel`.
+4. Else: run units sequentially.
 
 Never claim Task subagents were used when they were not.