@sellable/mcp 0.1.907 → 0.1.908

package/dist/tools/refill-executors.d.ts

@@ -269,6 +269,48 @@ export declare function validateAgentSuppliedBroadenKeywords(rawKeywords: unknow
     ok: false;
     reason: string;
 };
+type RefillV3SignalPostCandidate = {
+    postId: string;
+    postUrl: string;
+    totalEngagers: number;
+    recencyDays: number;
+};
+type RefillV3SignalPostEstimate = {
+    postId?: unknown;
+    sampleSize?: unknown;
+    passCount?: unknown;
+    fitPercentage?: unknown;
+    estimatedFits?: unknown;
+};
+export type RefillV3SignalPostSample = {
+    postId: string;
+    sampleSize: number;
+    passCount: number;
+    fitRate: number;
+    totalEngagers: number;
+    projectedFits: number;
+    qualifies: boolean;
+};
+export declare function selectRefillV3SignalPostsFromSamples(params: {
+    candidates: readonly RefillV3SignalPostCandidate[];
+    estimates: readonly RefillV3SignalPostEstimate[];
+    maxPosts: number;
+}): {
+    samples: RefillV3SignalPostSample[];
+    selectedPostIds: string[];
+    yieldEvidence: {
+        family: "signal_discovery";
+        evaluated: number;
+        passes: number;
+    };
+    qualityGateEvidence: {
+        family: "signal_discovery";
+        evaluated: number;
+        passes: number;
+    };
+    engagerSum: number;
+    projectedYield: number;
+};
 export declare function recentBroadenablePostIdsFromSignalSearch(summary: Awaited<ReturnType<typeof searchSignals>>, options: {
     maxAgeDays: number;
     excludePostIds?: string[];

package/dist/tools/refill-executors.js

@@ -6,6 +6,7 @@ import { startPrepareCampaignMessages } from "./campaign-message-preparation.js"
 import { normalizeMessageTemplateRevision, normalizeRefillRunHandle, normalizeRefillTargetConfig, reviseMessageTemplateAndRerun, } from "./campaign-processing.js";
 import { startCampaign } from "./campaigns.js";
 import { confirmLeadList, importLeads, searchProspeo, searchSalesNav, searchSignals, selectPromisingPosts, } from "./leads.js";
+import { REFILL_V3_SIGNAL_POST_MIN_ICP_RATE, REFILL_V3_SIGNAL_POST_MIN_SAMPLE_SIZE, REFILL_V3_SIGNAL_POST_SAMPLE_CANDIDATE_CAP, } from "./refill-v3-attention-packet-contract.js";
 import { refreshSenderEngagementCommand } from "./refresh-sender-engagement.js";
 import { runSchedulerSweep, } from "./scheduler-run.js";
 import { refreshPaidInmailCredits } from "./senders.js";
@@ -132,10 +133,26 @@ export function normalizeRefillV3SourceOwnerReceipt(params) {
     const signalKeywords = stringArray(rawRecord.keywordsTried);
     const signalSelectedPostIds = stringArray(rawRecord.selectedPostIds);
     const signalExcludedPostIds = stringArray(rawRecord.excludedPostIds);
+    const signalImportResult = recordValue(rawRecord.importResult);
+    const signalImportJobId = stringValue(signalImportResult?.jobId);
+    if (isSignalOwner &&
+        rawRecord.rowsGainedPending === true &&
+        signalImportJobId) {
+        // Signal import is asynchronous. Starting its scrape is not a zero-row
+        // terminal: return a retained effect identity so the coordinator reobserves
+        // the live source job instead of recording a dry round and spending the
+        // keyword avenue before any rows can arrive.
+        return {
+            kind: "pending",
+            effectIdentity: signalImportJobId,
+            detail: `Signal import ${signalImportJobId} started and rows are pending; reobserve the source job before classifying yield.`,
+        };
+    }
     const signalRowsGained = Math.max(0, numberValue(rawRecord.rowsGained) ?? 0);
     const signalProjection = recordValue(rawRecord.yieldProjection);
-    const signalEvaluated = Math.max(0, Math.floor(numberValue(signalProjection?.engagerSum) ?? 0));
-    const signalPasses = Math.min(signalEvaluated, Math.max(0, Math.floor(numberValue(signalProjection?.projectedYield) ?? 0)));
+    const signalYieldRecord = recordValue(rawRecord.yieldEvidence);
+    const signalYieldEvaluated = Math.max(0, Math.floor(numberValue(signalYieldRecord?.evaluated) ?? 0));
+    const signalYieldPasses = Math.min(signalYieldEvaluated, Math.max(0, Math.floor(numberValue(signalYieldRecord?.passes) ?? 0)));
     const synthesizedBelowFloorRecord = signalBelowFloor && signalCampaignId && priorSourceFingerprint
         ? {
             ...rawRecord,
@@ -156,6 +173,10 @@ export function normalizeRefillV3SourceOwnerReceipt(params) {
             importedCount: 0,
             effects: [
                 "signal_yield_below_floor",
+                ...(stringValue(rawRecord.failureCode) ===
+                    "signal_post_icp_below_floor"
+                    ? ["signal_post_icp_below_floor"]
+                    : []),
                 `keywords_searched:${signalKeywords.length}`,
                 `candidate_posts:${Math.max(0, numberValue(signalProjection?.candidatePostCount) ?? 0)}`,
                 `projected_yield:${Math.max(0, numberValue(signalProjection?.projectedYield) ?? 0)}`,
@@ -234,11 +255,14 @@ export function normalizeRefillV3SourceOwnerReceipt(params) {
             }
             : { available: false, reason: "not_applicable" },
         postRationales: null,
-        yieldEvidence: isSignalOwner && signalEvaluated > 0
+        // `yieldProjection` is volume planning (`engagers * assumed pass rate`),
+        // not observed candidate qualification. The dispatcher attaches actual
+        // candidate verdict evidence when it exists.
+        yieldEvidence: isSignalOwner && signalYieldEvaluated > 0
             ? {
                 family: "signal_discovery",
-                evaluated: signalEvaluated,
-                passes: signalPasses,
+                evaluated: signalYieldEvaluated,
+                passes: signalYieldPasses,
             }
             : null,
     };
@@ -950,6 +974,90 @@ export function validateAgentSuppliedBroadenKeywords(rawKeywords, negativeList)
     }
     return { ok: true, keywords: freshKeywords };
 }
+function refillV3SignalPostCandidates(summary, options) {
+    const excluded = new Set((options.excludePostIds ?? []).map((postId) => postId.toLowerCase()));
+    const topPosts = Array.isArray(summary?.topPosts)
+        ? summary.topPosts
+        : [];
+    const seen = new Set();
+    const candidates = [];
+    for (const post of topPosts) {
+        const postId = stringValue(post.id);
+        const postUrl = stringValue(post.url);
+        const recencyDays = numberValue(post.recencyDays);
+        if (!postId ||
+            !postUrl ||
+            recencyDays === null ||
+            recencyDays > options.maxAgeDays ||
+            excluded.has(postId.toLowerCase()) ||
+            seen.has(postId.toLowerCase())) {
+            continue;
+        }
+        const totalEngagers = scrapablePostEngagers(post);
+        if (totalEngagers < 1)
+            continue;
+        seen.add(postId.toLowerCase());
+        candidates.push({ postId, postUrl, totalEngagers, recencyDays });
+        if (candidates.length >= REFILL_V3_SIGNAL_POST_SAMPLE_CANDIDATE_CAP)
+            break;
+    }
+    return candidates;
+}
+export function selectRefillV3SignalPostsFromSamples(params) {
+    const estimatesByPost = new Map(params.estimates
+        .map((estimate) => [stringValue(estimate.postId), estimate])
+        .filter((entry) => Boolean(entry[0])));
+    const samples = params.candidates.flatMap((candidate) => {
+        const estimate = estimatesByPost.get(candidate.postId);
+        const sampleSize = Math.max(0, Math.floor(numberValue(estimate?.sampleSize) ?? 0));
+        const passCount = Math.min(sampleSize, Math.max(0, Math.floor(numberValue(estimate?.passCount) ?? 0)));
+        if (sampleSize === 0)
+            return [];
+        const fitRate = passCount / sampleSize;
+        return [
+            {
+                postId: candidate.postId,
+                sampleSize,
+                passCount,
+                fitRate,
+                totalEngagers: candidate.totalEngagers,
+                projectedFits: Math.floor(candidate.totalEngagers * fitRate),
+                qualifies: sampleSize >= REFILL_V3_SIGNAL_POST_MIN_SAMPLE_SIZE &&
+                    fitRate >= REFILL_V3_SIGNAL_POST_MIN_ICP_RATE,
+            },
+        ];
+    });
+    const candidateById = new Map(params.candidates.map((candidate) => [candidate.postId, candidate]));
+    const selected = samples
+        .filter((sample) => sample.qualifies)
+        .sort((left, right) => {
+        if (right.fitRate !== left.fitRate)
+            return right.fitRate - left.fitRate;
+        if (right.totalEngagers !== left.totalEngagers) {
+            return right.totalEngagers - left.totalEngagers;
+        }
+        return ((candidateById.get(left.postId)?.recencyDays ?? Infinity) -
+            (candidateById.get(right.postId)?.recencyDays ?? Infinity));
+    })
+        .slice(0, Math.max(1, params.maxPosts));
+    const sampleSizeEligible = samples.filter((sample) => sample.sampleSize >= REFILL_V3_SIGNAL_POST_MIN_SAMPLE_SIZE);
+    return {
+        samples,
+        selectedPostIds: selected.map((sample) => sample.postId),
+        yieldEvidence: {
+            family: "signal_discovery",
+            evaluated: selected.reduce((sum, sample) => sum + sample.sampleSize, 0),
+            passes: selected.reduce((sum, sample) => sum + sample.passCount, 0),
+        },
+        qualityGateEvidence: {
+            family: "signal_discovery",
+            evaluated: sampleSizeEligible.reduce((sum, sample) => sum + sample.sampleSize, 0),
+            passes: sampleSizeEligible.reduce((sum, sample) => sum + sample.passCount, 0),
+        },
+        engagerSum: selected.reduce((sum, sample) => sum + sample.totalEngagers, 0),
+        projectedYield: selected.reduce((sum, sample) => sum + sample.projectedFits, 0),
+    };
+}
 // feat(110-23c): the broadenable NEW-post frontier. A post counts only when its
 // engagement recency is inside the 45-day window (unknown recency is treated as
 // out-of-window), it carries meaningful engagement (>=1 commenter or reactor), and
@@ -1741,6 +1849,8 @@ export async function broadenSignalSearch(action, workspaceId) {
     let newPostIds;
     let carriedRemainder;
     let yieldProjectionReceipt = null;
+    let postYieldSamples = null;
+    let observedYieldEvidence = null;
     if (carriedRound) {
         // Consume the carried frontier first: these posts were already found inside
         // the 45-day window by a prior round whose projection cleared the floor.
@@ -1801,21 +1911,67 @@ export async function broadenSignalSearch(action, workspaceId) {
                 },
             };
         }
-        // feat(110-23d, OWNER REFINEMENT #11): project the round's new-lead yield instead
-        // of a fuzzy per-post meaningful-engagement test. Sum the scrapable engager counts
-        // across the NEW candidate posts (inside the 45-day window, not already scraped) and
-        // multiply by the campaign's observed headline-ICP pass rate. When the projection
-        // falls below the floor min(remainingPrepGap, 100) — zero new posts being the
-        // projection=0 special case — terminalize typed (signal_yield_below_floor) with the
-        // projection receipt so the lane chain advances; otherwise scrape proceeds.
-        const yieldProjection = projectSignalBroadenYield(searchSummary, {
-            maxAgeDays,
-            excludePostIds: excludedPostIds,
-            observedPassRate,
-            remainingPrepGap,
-            maxPosts: maxPostsToScrape,
-        });
-        if (yieldProjection.projectedYield < yieldProjection.floor) {
+        const yieldProjection = isRefillV3SinglePassAction(action)
+            ? await (async () => {
+                const candidates = refillV3SignalPostCandidates(searchSummary, {
+                    maxAgeDays,
+                    excludePostIds: excludedPostIds,
+                });
+                if (candidates.length === 0) {
+                    return {
+                        candidatePostCount: 0,
+                        engagerSum: 0,
+                        observedPassRate: 0,
+                        projectedYield: 0,
+                        floor: Math.min(SIGNAL_YIELD_FLOOR_CAP, Math.max(1, remainingPrepGap)),
+                        scrapePostIds: [],
+                        carriedPostIds: [],
+                    };
+                }
+                const estimateResponse = await api.post("/api/v1/signal-discovery/estimate-icp-fits", {
+                    posts: candidates.map((candidate) => ({
+                        id: candidate.postId,
+                        url: candidate.postUrl,
+                        totalEngagers: candidate.totalEngagers,
+                    })),
+                    campaignOffer: {
+                        id: campaignOfferId,
+                        name: campaign.name ?? "",
+                    },
+                }, requestOptions);
+                const sampled = selectRefillV3SignalPostsFromSamples({
+                    candidates,
+                    estimates: estimateResponse.estimates ?? [],
+                    maxPosts: scrapeCap,
+                });
+                postYieldSamples = sampled.samples;
+                observedYieldEvidence =
+                    sampled.selectedPostIds.length > 0
+                        ? sampled.yieldEvidence
+                        : sampled.qualityGateEvidence;
+                const evaluated = observedYieldEvidence.evaluated;
+                return {
+                    candidatePostCount: candidates.length,
+                    engagerSum: sampled.engagerSum,
+                    observedPassRate: evaluated > 0 ? observedYieldEvidence.passes / evaluated : 0,
+                    projectedYield: sampled.projectedYield,
+                    floor: Math.min(SIGNAL_YIELD_FLOOR_CAP, Math.max(1, remainingPrepGap)),
+                    scrapePostIds: sampled.selectedPostIds,
+                    carriedPostIds: [],
+                };
+            })()
+            : projectSignalBroadenYield(searchSummary, {
+                maxAgeDays,
+                excludePostIds: excludedPostIds,
+                observedPassRate,
+                remainingPrepGap,
+                maxPosts: maxPostsToScrape,
+            });
+        const noQualifyingV3Post = isRefillV3SinglePassAction(action) &&
+            yieldProjection.scrapePostIds.length === 0;
+        if (noQualifyingV3Post ||
+            (!isRefillV3SinglePassAction(action) &&
+                yieldProjection.projectedYield < yieldProjection.floor)) {
             const runScopedCleanup = await cleanupRunScopedDerivedTabs();
             // fix(110-23e): the yield floor was evaluated on the ACTUAL candidates this
             // search round returned (zero candidates being the projection=0 special case).
@@ -1826,7 +1982,9 @@ export async function broadenSignalSearch(action, workspaceId) {
             // terminalizing the lane with the agent tier untried.
             return {
                 status: "refused",
-                refusalReason: `signal_yield_below_floor: projected new-lead yield ${yieldProjection.projectedYield} (${yieldProjection.engagerSum} scrapable engagers x ${yieldProjection.observedPassRate} observed headline-ICP pass rate across ${yieldProjection.candidatePostCount} NEW candidate posts) is below the floor ${yieldProjection.floor} (min(remaining prep gap, 100))${effectiveKeywordSource === "agent_supplied" ? "; the 45-day relevant Signal universe cannot fill the remaining gap" : "; escalate to the next keyword-source tier"}`,
+                refusalReason: noQualifyingV3Post
+                    ? `signal_yield_below_floor: signal_post_icp_below_floor: none of ${yieldProjection.candidatePostCount} sampled recent posts had at least ${REFILL_V3_SIGNAL_POST_MIN_SAMPLE_SIZE} evaluated engagers and a ${REFILL_V3_SIGNAL_POST_MIN_ICP_RATE * 100}% observed headline-ICP pass rate`
+                    : `signal_yield_below_floor: projected new-lead yield ${yieldProjection.projectedYield} (${yieldProjection.engagerSum} scrapable engagers x ${yieldProjection.observedPassRate} observed headline-ICP pass rate across ${yieldProjection.candidatePostCount} NEW candidate posts) is below the floor ${yieldProjection.floor} (min(remaining prep gap, 100))${effectiveKeywordSource === "agent_supplied" ? "; the 45-day relevant Signal universe cannot fill the remaining gap" : "; escalate to the next keyword-source tier"}`,
                 result: {
                     campaignOfferId,
                     keywordSource: effectiveKeywordSource,
@@ -1849,6 +2007,13 @@ export async function broadenSignalSearch(action, workspaceId) {
                         projectedYield: yieldProjection.projectedYield,
                         floor: yieldProjection.floor,
                     },
+                    ...(postYieldSamples ? { postYieldSamples } : {}),
+                    ...(observedYieldEvidence
+                        ? { yieldEvidence: observedYieldEvidence }
+                        : {}),
+                    ...(noQualifyingV3Post
+                        ? { failureCode: "signal_post_icp_below_floor" }
+                        : {}),
                     newPostCount: 0,
                     maxAgeDays,
                     universeExhausted: effectiveKeywordSource === "agent_supplied",
@@ -1873,7 +2038,10 @@ export async function broadenSignalSearch(action, workspaceId) {
             campaignOfferId,
             selections: newPostIds.map((postId) => ({
                 postId,
-                reason: "refill_sends signal broadening: NEW recent post (<=45 days) with meaningful engagement, derived from fresh keywords within the campaign's existing search intent",
+                reason: postYieldSamples
+                    ? `refill_sends Signal post sample: ${Math.round((postYieldSamples.find((sample) => sample.postId === postId)
+                        ?.fitRate ?? 0) * 1000) / 10}% observed headline-ICP fit (minimum ${REFILL_V3_SIGNAL_POST_MIN_ICP_RATE * 100}%)`
+                    : "refill_sends signal broadening: NEW recent post (<=45 days) with meaningful engagement, derived from fresh keywords within the campaign's existing search intent",
             })),
             headlineICPCriteria,
             currentStep: null,
@@ -1972,6 +2140,10 @@ export async function broadenSignalSearch(action, workspaceId) {
             ...(yieldProjectionReceipt
                 ? { yieldProjection: yieldProjectionReceipt }
                 : {}),
+            ...(postYieldSamples ? { postYieldSamples } : {}),
+            ...(observedYieldEvidence
+                ? { yieldEvidence: observedYieldEvidence }
+                : {}),
             // The run-scoped progress gate reads newPostCount: a productive round keeps
             // the rung re-emittable; a zero round would have terminalized above.
             newPostCount: newPostIds.length,

package/dist/tools/refill-v3-attention-packet-contract.d.ts

@@ -171,6 +171,14 @@ export declare const REFILL_V3_DIAGNOSTIC_SAMPLE_CAP = 10;
 export declare const REFILL_V3_MIN_SOURCE_YIELD = 0.08;
 /** The acceptance sample is a fixed number of EVALUATED candidates. */
 export declare const REFILL_V3_MIN_SOURCE_YIELD_SAMPLE = 20;
+/**
+ * Signal Discovery has a stricter post-level gate than the shared source
+ * receipt floor: each individual post must clear 10% on a real sample before
+ * that post may be selected for scraping.
+ */
+export declare const REFILL_V3_SIGNAL_POST_MIN_ICP_RATE = 0.1;
+export declare const REFILL_V3_SIGNAL_POST_MIN_SAMPLE_SIZE = 20;
+export declare const REFILL_V3_SIGNAL_POST_SAMPLE_CANDIDATE_CAP = 5;
 /** `post_engager` is excluded: it keeps posts-refresh preconditions, not a rate. */
 export declare const REFILL_V3_YIELD_FLOOR_FAMILIES: readonly ["signal_discovery", "cold"];
 export type RefillV3YieldFloorFamily = (typeof REFILL_V3_YIELD_FLOOR_FAMILIES)[number];

package/dist/tools/refill-v3-attention-packet-contract.js

@@ -196,6 +196,14 @@ export const REFILL_V3_DIAGNOSTIC_SAMPLE_CAP = 10;
 export const REFILL_V3_MIN_SOURCE_YIELD = 0.08;
 /** The acceptance sample is a fixed number of EVALUATED candidates. */
 export const REFILL_V3_MIN_SOURCE_YIELD_SAMPLE = 20;
+/**
+ * Signal Discovery has a stricter post-level gate than the shared source
+ * receipt floor: each individual post must clear 10% on a real sample before
+ * that post may be selected for scraping.
+ */
+export const REFILL_V3_SIGNAL_POST_MIN_ICP_RATE = 0.1;
+export const REFILL_V3_SIGNAL_POST_MIN_SAMPLE_SIZE = 20;
+export const REFILL_V3_SIGNAL_POST_SAMPLE_CANDIDATE_CAP = 5;
 /** `post_engager` is excluded: it keeps posts-refresh preconditions, not a rate. */
 export const REFILL_V3_YIELD_FLOOR_FAMILIES = [
     "signal_discovery",

package/dist/tools/refill-v3-source-family-dispatch.d.ts

@@ -143,6 +143,11 @@ export type RefillV3SourceOwnerOutcome = {
 } | {
     kind: "no_effect";
     receipt: RefillV3SourceOwnerReceipt;
+} | {
+    /** The source mutation started an asynchronous import that has not settled. */
+    kind: "pending";
+    effectIdentity: string;
+    detail: string;
 } | {
     /** A closed provider-source business terminal, never infrastructure. */
     kind: "source_terminal";

package/dist/tools/refill-v3-source-family-dispatch.js

@@ -21,7 +21,7 @@
  * fingerprint-identified, and carries an explicit typed RELEASE CONDITION, so a
  * bounded attempt can never harden into a standing claim.
  */
-import { evaluateRefillV3SourceYield, REFILL_V3_EXHAUSTION_PREDICATE, REFILL_V3_LEAD_SOURCE_FAMILIES, REFILL_V3_MIN_SOURCE_YIELD, REFILL_V3_MIN_SOURCE_YIELD_SAMPLE, } from "./refill-v3-attention-packet-contract.js";
+import { evaluateRefillV3SourceYield, REFILL_V3_EXHAUSTION_PREDICATE, REFILL_V3_LEAD_SOURCE_FAMILIES, REFILL_V3_MIN_SOURCE_YIELD, REFILL_V3_MIN_SOURCE_YIELD_SAMPLE, REFILL_V3_SIGNAL_POST_MIN_ICP_RATE, } from "./refill-v3-attention-packet-contract.js";
 import { REFILL_V3_POSTS_KEYWORD_BATCH_SIZE, REFILL_V3_POSTS_MAX_SELECTED, REFILL_V3_POSTS_ROUND_BUDGET, } from "./refill-v3-campaign-work.js";
 // ───────────────────────────────────────────────────────────────────────────
 // The constant owner table
@@ -450,26 +450,62 @@ export async function dispatchRefillV3SourceFamily(input) {
             reobserveRequired: true,
         };
     }
-    const receipt = outcome.receipt;
-    if (!isNonEmpty(receipt.sourceBeforeFingerprint) ||
-        !isNonEmpty(receipt.sourceAfterFingerprint) ||
-        !isNonEmpty(receipt.requestFingerprint) ||
-        !isNonEmpty(receipt.idempotencyKey)) {
+    if (outcome.kind === "pending") {
+        return {
+            kind: "scoped_failure",
+            family: command.family,
+            failureClass: "uncertain",
+            retryable: true,
+            effectIdentity: outcome.effectIdentity,
+            detail: `${ownerKey}: ${outcome.detail}`,
+            exhausted: false,
+            reobserveRequired: true,
+        };
+    }
+    const ownerReceipt = outcome.receipt;
+    if (!isNonEmpty(ownerReceipt.sourceBeforeFingerprint) ||
+        !isNonEmpty(ownerReceipt.sourceAfterFingerprint) ||
+        !isNonEmpty(ownerReceipt.requestFingerprint) ||
+        !isNonEmpty(ownerReceipt.idempotencyKey)) {
         return refused("receipt_incomplete", `${ownerKey} returned a receipt without complete source before/after and request evidence; uncertain evidence is never success.`);
     }
     // 14. The AI's recorded per-candidate verdicts feed the SHARED floor. The
     //     arithmetic, the comparison, and the routing are deterministic; there is
     //     no deterministic candidate judge.
     const verdicts = input.candidateVerdicts ?? null;
-    const yieldVerdict = verdicts && verdicts.length > 0
-        ? evaluateRefillV3DispatchYield({
-            family: command.family,
-            evaluated: verdicts.length,
-            passes: verdicts.filter((entry) => entry.verdict === "pass").length,
-        })
-        : receipt.yieldEvidence
-            ? evaluateRefillV3DispatchYield(receipt.yieldEvidence)
-            : null;
+    const auditedYieldEvidence = command.family === "signal_discovery" && ownerReceipt.yieldEvidence
+        ? ownerReceipt.yieldEvidence
+        : verdicts && verdicts.length > 0
+            ? {
+                family: command.family,
+                evaluated: verdicts.length,
+                passes: verdicts.filter((entry) => entry.verdict === "pass").length,
+            }
+            : ownerReceipt.yieldEvidence;
+    // Signal's owner-level `yieldProjection` is volume planning based on an
+    // assumed pass rate. It is never a sampled qualification result. The owner
+    // receipt now exposes only real post-level sample evidence, which is
+    // authoritative over an agent's pre-search candidate judgement.
+    const receipt = {
+        ...ownerReceipt,
+        yieldEvidence: auditedYieldEvidence,
+    };
+    const signalPostFloorRejected = ownerReceipt.effects.includes("signal_post_icp_below_floor");
+    const yieldVerdict = auditedYieldEvidence
+        ? signalPostFloorRejected
+            ? auditedYieldEvidence.evaluated < REFILL_V3_MIN_SOURCE_YIELD_SAMPLE
+                ? {
+                    decision: "sample_incomplete",
+                    evaluated: auditedYieldEvidence.evaluated,
+                    required: REFILL_V3_MIN_SOURCE_YIELD_SAMPLE,
+                }
+                : {
+                    decision: "below_floor",
+                    ratio: auditedYieldEvidence.passes / auditedYieldEvidence.evaluated,
+                    floor: REFILL_V3_SIGNAL_POST_MIN_ICP_RATE,
+                }
+            : evaluateRefillV3DispatchYield(auditedYieldEvidence)
+        : null;
     // A round that MEETS the floor is a qualifying source: import and stop
     // broadening, so its fingerprint is not a refusal for later rounds. Every
     // other completed round registers so it cannot repeat unchanged.

package/package.json

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

package/skills/providers/signal-discovery.md

@@ -136,8 +136,8 @@ You must estimate:
     floor is a viability reject threshold, not the denominator when the sample
     rate is higher.
 - `planningFloor`
-  - minimum acceptable sampled/projected headline-fit rate; default 10%.
-    Below this, do not scale Signal Discovery.
+  - minimum acceptable observed headline-fit rate for each sampled post;
+    default 10%. Below this, do not scrape that post.
 - `projectedRange`
   - the conservative range implied by the observed sample
 
@@ -164,9 +164,11 @@ Use conservative logic:
    - preferred: "`sampledCount`: 40, `passCount`: 9, `passRate`: ~22%, `goodFitPer100Engagers`: ~22 headline-fit prospects, `requiredEngagersToScrape`: ~1,365 raw engagers for a 300 headline-fit target before a practical coverage buffer, `avgReachableEngagersPerPost`: 240, `goodFitProspectsPerPost`: ~53, `postsNeededForTarget`: ~6, `recentStrongPostCount`: 15-25, `freshEnoughPostCount`: 8-12, `projectedRange`: 300-380 from selected posts"
    - fallback: "I could not fetch engagers, so this is inferred from post and author quality only"
 5. If the evidence is too weak, say so and return a low-confidence estimate instead of pretending precision.
-6. If sampled/projected headline-fit rate is below the 10% planning floor,
-   reject the Signal Discovery scrape path and recommend Sales Nav recent
-   activity as the next source.
+6. Decide per post. Keep only posts whose own real engager sample clears the
+   10% planning floor; never pool all candidate posts or substitute a default
+   planning rate for an observed sample. If no sampled post clears 10%, reject
+   this Signal Discovery round and recommend Sales Nav recent activity as the
+   next source.
 7. Do not manually enumerate dozens of engagers in the final answer. Summarize the sample by `sampledCount`, `passCount`, `passRate`, `projectedRange`, and 3-6 representative examples.
 
 </yield_estimation>
@@ -448,7 +450,8 @@ recommendation, estimate source capacity from real sample math:
 - average reachable engagers per right-content post
 - expected headline-fit leads per selected post
 - posts needed to reach the target
-- whether sampled/projected headline-fit rate clears the 10% planning floor
+- each selected post's sampled headline-fit rate and whether it clears the 10%
+  planning floor
 
 Then select the smallest right-content post set that plausibly hits the source
 target. Do not scrape every promoted sample post by default; promoted sampling
@@ -457,8 +460,8 @@ state and final scrape plan are separate. If one 1,200+ engager post clears a
 sample set. If the math says the warm post lane only supports a smaller first
 batch, say that and name the Sales Nav or Prospeo scale fallback rather than
 padding the selection with noisy posts. If the
-sampled/projected headline-fit rate is below 10%, do not call
-`import_leads`; move to Sales Nav recent activity.
+sampled headline-fit rate for a post is below 10%, exclude that post from
+`import_leads`. If no sampled post clears 10%, move to Sales Nav recent activity.
 
 ```json
 select_promising_posts({

package/skills/refill-sends-work-campaign/SKILL.md

@@ -285,10 +285,10 @@ For a signal-discovery posts search:
   receipt's `remainingCorrectionAttempts: 1` is consumed by that one revised
   decision; a second collision is terminal and must never loop.
 - Apply both quality gates from the Signal provider contract: recent relevant
-  post quality first, then a 10% minimum sampled/projected headline-ICP pass
-  rate. The deterministic capacity check uses that pass rate against the
-  exact remaining refill gap; it does not require an arbitrary 100 qualified
-  leads when only a smaller gap remains.
+  post quality first, then a 10% minimum observed headline-ICP pass rate on a
+  real engager sample for each specific post. Never pool candidate-post
+  engagement, apply a default rate, or relabel projected volume as observed
+  qualification. Import only the individual posts that clear 10%.
 - select AT MOST 5 candidate posts from that round's results;
 - pick the BEST posts in this order: (1) expected ICP fit of the post's engagers,
   (2) engagement volume high enough that scraping is efficient — qualified