@sellable/mcp 0.1.908 → 0.1.909

package/dist/tools/refill-executors.js

@@ -135,19 +135,9 @@ export function normalizeRefillV3SourceOwnerReceipt(params) {
     const signalExcludedPostIds = stringArray(rawRecord.excludedPostIds);
     const signalImportResult = recordValue(rawRecord.importResult);
     const signalImportJobId = stringValue(signalImportResult?.jobId);
-    if (isSignalOwner &&
+    const signalImportPending = 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.`,
-        };
-    }
+        signalImportJobId !== null;
     const signalRowsGained = Math.max(0, numberValue(rawRecord.rowsGained) ?? 0);
     const signalProjection = recordValue(rawRecord.yieldProjection);
     const signalYieldRecord = recordValue(rawRecord.yieldEvidence);
@@ -266,6 +256,19 @@ export function normalizeRefillV3SourceOwnerReceipt(params) {
             }
             : null,
     };
+    if (signalImportPending) {
+        // Search and per-post qualification have already completed at this point;
+        // only row materialization is asynchronous. Preserve that completed search
+        // receipt while returning the retained import identity. Otherwise the live
+        // job disappears after settlement with no negative-set entry and the outer
+        // coordinator offers the identical broadening round again.
+        return {
+            kind: "pending",
+            effectIdentity: signalImportJobId,
+            detail: `Signal import ${signalImportJobId} started and rows are pending; reobserve the source job before classifying yield.`,
+            receipt,
+        };
+    }
     return importedCount > 0
         ? { kind: "receipt", receipt }
         : { kind: "no_effect", receipt };

package/dist/tools/refill-v3-continue.js

@@ -860,6 +860,36 @@ export async function runRefillV3CampaignWorkWithProductionOwners(input, owners
                         after: sourceOutcome.receipt,
                     });
                 }
+                if (sourceOutcome.kind === "scoped_failure" &&
+                    sourceOutcome.pendingReceipt &&
+                    owners.recordSourceCycle) {
+                    // A Signal search has completed once the bounded posts were sampled
+                    // and its async import was launched. Record that round before
+                    // returning the retained job wait. Previously the pending branch
+                    // wrote nothing, so the job could settle and disappear while the
+                    // next advance still advertised the identical round as untried.
+                    await owners.recordSourceCycle({
+                        ...sourceCycleScope,
+                        ...sourceCycleRunFact,
+                        receipt: {
+                            schemaVersion: 1,
+                            kind: "search",
+                            campaignId: request.scope.campaignId,
+                            family: request.sourceCommand.family,
+                            protectedFitDigest,
+                            requestFingerprint: sourceOutcome.pendingReceipt.requestFingerprint,
+                            sourceFingerprint: sourceOutcome.pendingReceipt.sourceAfterFingerprint,
+                            keywordBatch: request.sourceCommand.keywordBatch,
+                            postIds: request.sourceCommand.selectedPostIds,
+                            // Row materialization is still pending. Zero here describes the
+                            // completed search receipt, not the eventual import yield; the
+                            // live job and fresh campaign/source observations own that.
+                            importedCount: 0,
+                            yieldEvidence: sourceOutcome.pendingReceipt.yieldEvidence,
+                            observedAt: request.scope.date,
+                        },
+                    });
+                }
                 const closedProviderFrontierSpent = sourceOutcome.kind === "source_terminal";
                 const qualitySafeProviderFrontierSpent = request.action === "broaden_source_family" &&
                     request.sourceCommand.family === "cold" &&
@@ -1323,12 +1353,18 @@ async function executeRefillV3Continuation(input, dependencies) {
             scopeFingerprint,
         }),
     });
-    if (!outcome.ok && outcome.correctiveContext !== undefined) {
+    // Source-owner refusals are valid, reobserved no-effect receipts. Their one
+    // correction still belongs to this exact packet and must return before the
+    // ordinary completed-work path releases the retained campaign.
+    const correctiveContext = outcome.ok
+        ? outcome.receipt?.correctiveContext
+        : outcome.correctiveContext;
+    if (correctiveContext !== undefined) {
         return {
             kind: "attention_correction_required",
             runToken,
             packet: advanceResult.packet,
-            correction: outcome.correctiveContext,
+            correction: correctiveContext,
             outcome,
         };
     }

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

@@ -144,10 +144,16 @@ export type RefillV3SourceOwnerOutcome = {
     kind: "no_effect";
     receipt: RefillV3SourceOwnerReceipt;
 } | {
-    /** The source mutation started an asynchronous import that has not settled. */
+    /**
+     * The search completed and the source mutation started an asynchronous
+     * import that has not settled. The completed-search receipt must be
+     * recorded before waiting so the same keyword/post round cannot reopen
+     * after the import job disappears from world state.
+     */
     kind: "pending";
     effectIdentity: string;
     detail: string;
+    receipt: RefillV3SourceOwnerReceipt;
 } | {
     /** A closed provider-source business terminal, never infrastructure. */
     kind: "source_terminal";
@@ -220,6 +226,8 @@ export type RefillV3SourceDispatchResult = {
     failureClass: RefillV3SourceFailureClass | "uncertain";
     retryable: true;
     effectIdentity: string | null;
+    /** Completed search evidence retained while its async import settles. */
+    pendingReceipt?: RefillV3SourceOwnerReceipt;
     detail: string;
     correctiveContext?: RefillV3AttentionCorrection;
     exhausted: false;

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

@@ -457,6 +457,7 @@ export async function dispatchRefillV3SourceFamily(input) {
             failureClass: "uncertain",
             retryable: true,
             effectIdentity: outcome.effectIdentity,
+            pendingReceipt: outcome.receipt,
             detail: `${ownerKey}: ${outcome.detail}`,
             exhausted: false,
             reobserveRequired: true,

package/package.json

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