@sellable/mcp 0.1.105 → 0.1.106

package/dist/tools/leads.js

@@ -2366,6 +2366,15 @@ export async function selectPromisingPosts(input) {
         headlineICPCriteria,
         rubricGuidelines: headlineICPCriteria,
     });
+    if (selectionResult.selectedCount <= 0) {
+        return {
+            success: false,
+            selectedCount: selectionResult.selectedCount,
+            unselectedCount: selectionResult.unselectedCount,
+            criteriaCount: selectionResult.criteriaCount,
+            message: "No Signal Discovery posts were selected for this campaign. Do not import yet. Re-run a campaign-scoped search_signals call, use recommendedPostIds from the current campaign search state, or ask the user to promote posts in the UI before retrying select_promising_posts.",
+        };
+    }
     // Update currentStep if provided (via v2 endpoint)
     if (currentStep) {
         await api.put(`/api/v2/campaign-offers/${campaignOfferId}`, {

package/dist/tools/rubrics.d.ts

@@ -32,6 +32,7 @@ type WaitForRubricResultsInput = {
     campaignOfferId?: string;
     tableId?: string;
     targetCount?: number;
+    minPassedCount?: number;
     timeoutMs?: number;
     intervalMs?: number;
     includeRows?: boolean;
@@ -109,6 +110,7 @@ export declare const rubricToolDefinitions: ({
             maxProspects?: undefined;
             tableId?: undefined;
             targetCount?: undefined;
+            minPassedCount?: undefined;
             timeoutMs?: undefined;
             intervalMs?: undefined;
             includeRows?: undefined;
@@ -141,6 +143,7 @@ export declare const rubricToolDefinitions: ({
             maxProspects?: undefined;
             tableId?: undefined;
             targetCount?: undefined;
+            minPassedCount?: undefined;
             timeoutMs?: undefined;
             intervalMs?: undefined;
             includeRows?: undefined;
@@ -198,6 +201,7 @@ export declare const rubricToolDefinitions: ({
             maxProspects?: undefined;
             tableId?: undefined;
             targetCount?: undefined;
+            minPassedCount?: undefined;
             timeoutMs?: undefined;
             intervalMs?: undefined;
             includeRows?: undefined;
@@ -255,6 +259,7 @@ export declare const rubricToolDefinitions: ({
             maxProspects?: undefined;
             tableId?: undefined;
             targetCount?: undefined;
+            minPassedCount?: undefined;
             timeoutMs?: undefined;
             intervalMs?: undefined;
             includeRows?: undefined;
@@ -314,6 +319,7 @@ export declare const rubricToolDefinitions: ({
             maxProspects?: undefined;
             tableId?: undefined;
             targetCount?: undefined;
+            minPassedCount?: undefined;
             timeoutMs?: undefined;
             intervalMs?: undefined;
             includeRows?: undefined;
@@ -343,6 +349,7 @@ export declare const rubricToolDefinitions: ({
             maxProspects?: undefined;
             tableId?: undefined;
             targetCount?: undefined;
+            minPassedCount?: undefined;
             timeoutMs?: undefined;
             intervalMs?: undefined;
             includeRows?: undefined;
@@ -372,6 +379,7 @@ export declare const rubricToolDefinitions: ({
             checkName?: undefined;
             tableId?: undefined;
             targetCount?: undefined;
+            minPassedCount?: undefined;
             timeoutMs?: undefined;
             intervalMs?: undefined;
             includeRows?: undefined;
@@ -397,6 +405,10 @@ export declare const rubricToolDefinitions: ({
                 type: string;
                 description: string;
             };
+            minPassedCount: {
+                type: string;
+                description: string;
+            };
             timeoutMs: {
                 type: string;
                 description: string;
@@ -496,6 +508,7 @@ export declare function waitForRubricResults(input: WaitForRubricResultsInput):
     elapsedMs: number;
     tableId: string;
     passRate: {
+        minPassedCount?: number | undefined;
         completed: number;
         passed: number;
         percent: number;
@@ -507,7 +520,10 @@ export declare function waitForRubricResults(input: WaitForRubricResultsInput):
     diagnostic?: undefined;
     guidance?: undefined;
 } | {
+    stats: WorkflowTableStats;
+    rows?: import("./rows.js").LightweightRow[] | undefined;
     ready: boolean;
+    partial: boolean;
     reason: string;
     attempts: number;
     elapsedMs: number;
@@ -518,6 +534,7 @@ export declare function waitForRubricResults(input: WaitForRubricResultsInput):
         pending: number;
         percent: number;
         targetCount: number;
+        minPassedCount: number;
     };
     partialResult: {
         completed: number;
@@ -525,7 +542,35 @@ export declare function waitForRubricResults(input: WaitForRubricResultsInput):
         pending: number;
         percent: number;
         targetCount: number;
+        minPassedCount: number;
+        enoughToDiagnose: boolean;
+        floorMet: boolean;
+    };
+    diagnostic?: undefined;
+    guidance?: undefined;
+} | {
+    ready: boolean;
+    reason: string;
+    attempts: number;
+    elapsedMs: number;
+    tableId: string;
+    passRate: {
+        minPassedCount?: number | undefined;
+        completed: number;
+        passed: number;
+        pending: number;
+        percent: number;
+        targetCount: number;
+    };
+    partialResult: {
         enoughToDiagnose: boolean;
+        floorMet: boolean;
+        minPassedCount?: number | undefined;
+        completed: number;
+        passed: number;
+        pending: number;
+        percent: number;
+        targetCount: number;
     };
     diagnostic: {
         totalRows: number;

package/dist/tools/rubrics.js

@@ -103,6 +103,11 @@ function resolveMaxProspects(value) {
     const parsed = typeof value === "number" && !Number.isNaN(value) ? value : fallback;
     return Math.min(MAX_PROSPECTS_LIMIT, Math.max(1, Math.floor(parsed)));
 }
+function resolveMinPassedCount(value) {
+    if (typeof value !== "number" || Number.isNaN(value))
+        return null;
+    return Math.min(MAX_PROSPECTS_LIMIT, Math.max(1, Math.floor(value)));
+}
 function mergeRubricsWithExisting(draftRubrics, existingRubrics) {
     const existingByCheckName = new Map();
     existingRubrics.forEach((item) => {
@@ -348,6 +353,10 @@ export const rubricToolDefinitions = [
                     type: "number",
                     description: `Number of completed rubric results to wait for (default ${DEFAULT_MAX_PROSPECTS}).`,
                 },
+                minPassedCount: {
+                    type: "number",
+                    description: "Optional pass floor for bounded create-campaign samples. When this floor is met and remaining target rows are resolved as failed/not processing, the tool returns ready:true with partial:true instead of forcing a timeout.",
+                },
                 timeoutMs: {
                     type: "number",
                     description: `Max time to wait in ms (default ${DEFAULT_TIMEOUT_MS}).`,
@@ -625,6 +634,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 minPassedCount = resolveMinPassedCount(input.minPassedCount);
     const includeRows = input.includeRows !== false;
     let tableId = input.tableId;
     if (!tableId && input.campaignOfferId) {
@@ -642,10 +652,17 @@ export async function waitForRubricResults(input) {
         const stats = await api.get(`/api/v3/workflow-tables/${tableId}/stats`);
         lastStats = stats;
         const completed = stats.passRate?.completed ?? 0;
+        const passed = stats.passRate?.passed ?? 0;
         const totalRows = stats.totalRows ?? 0;
         const effectiveTarget = totalRows > 0 ? Math.min(targetCount, totalRows) : targetCount;
+        const pending = Math.max(effectiveTarget - completed, 0);
+        const failedCount = stats.failedCount ?? 0;
+        const processingCount = stats.processingCount ?? 0;
+        const needsEnrichCount = stats.needsEnrichCount ?? 0;
+        const minPassFloorMet = minPassedCount !== null && passed >= minPassedCount;
+        const unresolvedRowsResolvedAsFailures = pending > 0 && completed + failedCount >= effectiveTarget;
+        const noActiveProcessing = processingCount === 0 && needsEnrichCount === 0;
         if (completed >= effectiveTarget) {
-            const passed = stats.passRate?.passed ?? 0;
             const percent = completed > 0 ? Math.round((passed / completed) * 100) : 0;
             const rowSnapshot = includeRows
                 ? await getTableRowsMinimal(tableId, {
@@ -662,6 +679,45 @@ export async function waitForRubricResults(input) {
                     passed,
                     percent,
                     targetCount: effectiveTarget,
+                    ...(minPassedCount !== null ? { minPassedCount } : {}),
+                },
+                ...(rowSnapshot ? { rows: rowSnapshot.rows } : {}),
+                stats,
+            };
+        }
+        if (minPassFloorMet &&
+            unresolvedRowsResolvedAsFailures &&
+            noActiveProcessing) {
+            const percent = completed > 0 ? Math.round((passed / completed) * 100) : 0;
+            const rowSnapshot = includeRows
+                ? await getTableRowsMinimal(tableId, {
+                    limit: effectiveTarget,
+                })
+                : null;
+            return {
+                ready: true,
+                partial: true,
+                reason: "min_passed_count_met_with_resolved_failures",
+                attempts,
+                elapsedMs: Date.now() - start,
+                tableId,
+                passRate: {
+                    completed,
+                    passed,
+                    pending,
+                    percent,
+                    targetCount: effectiveTarget,
+                    minPassedCount,
+                },
+                partialResult: {
+                    completed,
+                    passed,
+                    pending,
+                    percent,
+                    targetCount: effectiveTarget,
+                    minPassedCount,
+                    enoughToDiagnose: true,
+                    floorMet: true,
                 },
                 ...(rowSnapshot ? { rows: rowSnapshot.rows } : {}),
                 stats,
@@ -687,6 +743,7 @@ export async function waitForRubricResults(input) {
             pending,
             percent,
             targetCount: effectiveTarget,
+            ...(minPassedCount !== null ? { minPassedCount } : {}),
         },
         partialResult: {
             completed,
@@ -694,7 +751,9 @@ export async function waitForRubricResults(input) {
             pending,
             percent,
             targetCount: effectiveTarget,
+            ...(minPassedCount !== null ? { minPassedCount } : {}),
             enoughToDiagnose: completed > 0,
+            floorMet: minPassedCount !== null && passed >= minPassedCount,
         },
         diagnostic: {
             totalRows,

package/package.json

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

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

@@ -1943,17 +1943,23 @@
         {
           "tool": "wait_for_rubric_results",
           "requiredFields": [
-            "targetCount"
+            "targetCount",
+            "minPassedCount"
           ],
           "targetCountSource": "stats.totalRows_or_imported_batch_count",
+          "minPassedCountSource": "sample.minProjectedPass (3)",
           "requiredValues": {
             "includeRows": false
           },
-          "note": "The shell-first flow tests 15 leads first; always pass cohortSize explicitly instead of relying on default 25 behavior.",
+          "note": "The shell-first flow tests 15 leads first; always pass cohortSize explicitly instead of relying on default 25 behavior. Pass minPassedCount so a 15-row batch with resolved failures can advance when the 3-pass floor is already met.",
           "readVia": "stats_only_tool_result",
           "extractFields": [
             "ready",
+            "partial",
+            "reason",
             "passRate.completed",
+            "passRate.passed",
+            "passRate.minPassedCount",
             "stats"
           ],
           "doNotRetain": "rows_payload",

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

@@ -224,6 +224,17 @@ campaignOfferId, confirmed: true })` -> `search_signals({ campaignOfferId,
 selectionMode: "replace", selections, headlineICPCriteria })` ->
      `import_leads({ campaignOfferId, provider: "signal-discovery",
 targetLeadCount: importLimit })`.
+     For Signal Discovery, the promotion/select step is load-bearing. Use
+     post IDs from the current campaign-scoped `search_signals` response or
+     posts the user has visibly promoted in the campaign UI. Never use post IDs
+     copied only from a source-scout summary unless they have been re-resolved
+     through the current campaign search state. After `select_promising_posts`,
+     require `selectedCount > 0` before calling `import_leads`. If it returns
+     `selectedCount: 0`, do not switch providers and do not retry import.
+     Explain that the campaign has no promoted Signal Discovery posts yet,
+     re-run a narrow campaign-scoped `search_signals` call to recover current
+     post rows, or ask the user to promote the desired posts in the UI and then
+     retry `import_leads`.
      Source approval is the explicit confirmation for this bounded review
      batch; do not ask for a second yes/no gate between
      `select_promising_posts` and `import_leads`.
@@ -275,11 +286,14 @@ Shape:
 queue_cells({ tableId: workflowTableId, cellIds: reviewBatchEnrichCellIds })
 wait_for_campaign_table_ready({ tableId: workflowTableId })
 get_rows_minimal({ tableId: workflowTableId })
-wait_for_rubric_results({ tableId: workflowTableId, targetCount: cohortSize, includeRows: false })
+wait_for_rubric_results({ tableId: workflowTableId, targetCount: cohortSize, minPassedCount: minProjectedPass, includeRows: false })
 passInSample = count of first sampleSize review-batch rows with passesRubric === true
 projectedPass = round(passInSample / sampleSize * importLimit)
 
-if wait_for_rubric_results.ready === false and reason === "timeout":
+if wait_for_rubric_results.ready === true and partial === true and reason === "min_passed_count_met_with_resolved_failures":
+    use the partial passRate/stats as a valid sample diagnostic
+    continue if projectedPass >= minProjectedPass and generated messages are present for the passing rows
+else if wait_for_rubric_results.ready === false and reason === "timeout":
     use the partial passRate/stats as the sample diagnostic
     if active processing is visible:
         wait one more time at most

package/skills/providers/signal-discovery.md

@@ -377,6 +377,14 @@ selections, headlineICPCriteria })`, then call
 targetLeadCount })` for the approved review batch without asking for another
 yes/no gate. Do not import more than the approved bounded batch.
 
+The promotion/select step is required campaign state. Use post IDs from the
+current campaign-scoped search result, not stale IDs copied from a source review
+or scout summary. If `select_promising_posts` returns `selectedCount: 0`, stop:
+do not call `import_leads`, do not switch providers automatically, and do not
+claim the source failed. Re-run a narrow campaign-scoped search to recover
+current post rows, or have the user promote the posts in the UI and then retry
+the bounded import.
+
 ```json
 import_leads({
   "campaignOfferId": "cmp_xxx",