@sellable/mcp 0.1.793 → 0.1.794

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

@@ -0,0 +1,654 @@
+import { createHash } from "node:crypto";
+import { SellableApiError } from "../api.js";
+import { advanceRefillV3Tool, } from "./refill-v3-advance.js";
+import { REFILL_V3_ACTION_RESULTS, REFILL_V3_PREPARATION_REUSE_POINTS, decodeRefillV3CampaignWorkOutput, runRefillV3CampaignWork, } from "./refill-v3-campaign-work.js";
+import { REFILL_V3_CONTINUE_INPUT_SCHEMA, REFILL_V3_CONTINUE_OUTPUT_SCHEMA, decodeRefillV3ContinuePacket, } from "./refill-v3-continue-contract.js";
+import { dispatchRefillV3SourceFamily, } from "./refill-v3-source-family-dispatch.js";
+import { getRefillV3WorldStateTool } from "./refill-v3-world-state.js";
+import { normalizeExplicitWorkspaceId } from "./workspace-context.js";
+export const REFILL_V3_CONTINUE_TOOL_NAME = "refill_v3_continue";
+export const refillV3ContinueToolDefinitions = [
+    {
+        name: REFILL_V3_CONTINUE_TOOL_NAME,
+        description: "Continue exactly one server-issued Refill V3 campaign-attention decision. The tool first calls the deterministic advance owner against a fresh observation. If the world changed, it returns that fresh result or fresh attention packet without executing the stale decision. Only an exact packet match can dispatch one existing campaign-work authority, which then re-observes the exact sender/date. The caller cannot supply batch sizes, readiness digests, retry counters, fill inputs, scheduler inputs, or idempotency keys.",
+        inputSchema: REFILL_V3_CONTINUE_INPUT_SCHEMA,
+        outputSchema: REFILL_V3_CONTINUE_OUTPUT_SCHEMA,
+        annotations: {
+            title: "Refill V3 Continue",
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+];
+function canonical(value) {
+    const normalize = (current) => {
+        if (Array.isArray(current))
+            return current.map(normalize);
+        if (!current || typeof current !== "object")
+            return current;
+        return Object.fromEntries(Object.entries(current)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => [key, normalize(entry)]));
+    };
+    return JSON.stringify(normalize(value));
+}
+function samePacket(left, right) {
+    return canonical(left) === canonical(right);
+}
+function activePreparationConflict(error) {
+    if (!(error instanceof SellableApiError) || error.status !== 409)
+        return null;
+    let parsed = null;
+    try {
+        parsed = JSON.parse(error.body);
+    }
+    catch {
+        parsed = null;
+    }
+    const body = parsed && typeof parsed === "object" && !Array.isArray(parsed)
+        ? parsed
+        : {};
+    const activeJobId = typeof body.activeJobId === "string" && body.activeJobId.trim()
+        ? body.activeJobId
+        : null;
+    const message = typeof body.error === "string" ? body.error : error.message;
+    return activeJobId ||
+        /active prepare messages job already exists/i.test(message)
+        ? { activeJobId }
+        : null;
+}
+const DEFAULT_PRODUCTION_OWNERS = {
+    selectCampaignCells,
+    selectRepairableCampaignCells,
+    getPrepareCampaignMessagesStatus,
+    startPrepareCampaignMessages,
+    getProviderPrompt,
+    executeRerunErroredCellsPrimitive,
+    refillV3SourceFamilyOwners,
+    dispatchRefillV3SourceFamily,
+    broadenRubrics,
+    getRefillV3WorldStateTool,
+};
+export async function runRefillV3CampaignWorkWithProductionOwners(input, owners = DEFAULT_PRODUCTION_OWNERS) {
+    const decoded = decodeRefillV3CampaignWorkOutput(input.output);
+    const chosen = decoded.ok ? decoded.value.actions[0] : null;
+    let diagnosticRows = [];
+    const record = (value) => value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+    const stringValue = (value) => typeof value === "string" && value.trim() ? value : null;
+    const stringArray = (value) => Array.isArray(value)
+        ? value.filter((entry) => typeof entry === "string" && entry.length > 0)
+        : [];
+    const fingerprint = (value) => createHash("sha256").update(canonical(value)).digest("hex");
+    const scopeEcho = `${input.packet.scope.workspaceId}:${input.packet.scope.campaignId}:${input.packet.scope.tableId}`;
+    const receipt = (params) => ({
+        outcome: params.outcome,
+        result: params.result,
+        scopeEcho,
+        idempotencyKey: params.idempotencyKey,
+        beforeFingerprint: params.outcome === "applied"
+            ? input.packet.scope.evidenceFingerprint
+            : null,
+        afterFingerprint: params.outcome === "applied" ? fingerprint(params.after) : null,
+        changedFields: params.changedFields ?? [],
+        effectKey: params.outcome === "applied" ? params.idempotencyKey : null,
+        rollback: params.outcome === "applied"
+            ? { available: false, input: null, result: null }
+            : null,
+        reobserveRequired: true,
+        preparationDelegation: params.preparationDelegation ?? null,
+        systemicError: false,
+        lowPass: false,
+        refusalReason: params.refusalReason ?? null,
+    });
+    const dependencies = {
+        async loadDiagnosticSample({ workspaceId, campaignId, tableId, limit, }) {
+            const regenerate = chosen?.action === "regenerate_stale_messages";
+            const repairing = chosen?.action === "rerun_errored_cells";
+            const selected = repairing
+                ? await owners.selectRepairableCampaignCells({
+                    workspaceId,
+                    campaignId,
+                    tableId,
+                    limit,
+                })
+                : await owners.selectCampaignCells({
+                    workspaceId,
+                    campaignId,
+                    tableId,
+                    columnRole: regenerate ? "generateMessage" : "enrich",
+                    // The diagnostic is the server-owned canonical frontier the model
+                    // consumed, never the action's chosen subset. `rowIds` names which
+                    // rows inside this frontier one authority may touch; using it to
+                    // rebuild the diagnostic made the same identity appear twice with
+                    // contradictory meanings and rejected otherwise-valid decisions.
+                    rowSelector: regenerate
+                        ? { type: "needsGeneratedMessage" }
+                        : { type: "needsEnrichment" },
+                    diagnostic: { limit },
+                });
+            const diagnostic = record(record(selected)?.diagnostic);
+            const selectedRows = repairing
+                ? record(selected)?.rows
+                : diagnostic?.rows;
+            diagnosticRows = Array.isArray(selectedRows)
+                ? selectedRows.flatMap((entry) => {
+                    const row = record(entry);
+                    return row ? [row] : [];
+                })
+                : [];
+            const orderedRowIds = diagnosticRows.flatMap((row) => {
+                const rowId = stringValue(row.rowId);
+                return rowId ? [rowId] : [];
+            });
+            const failedRowIds = [];
+            const failureEvidence = [];
+            const unenrichedRowIds = [];
+            for (const row of diagnosticRows) {
+                const rowId = stringValue(row.rowId);
+                if (!rowId)
+                    continue;
+                const cells = Array.isArray(row.cells)
+                    ? row.cells.flatMap((entry) => {
+                        const cell = record(entry);
+                        return cell ? [cell] : [];
+                    })
+                    : [];
+                const enrich = cells.find((cell) => cell.columnRole === "enrich");
+                if (!enrich ||
+                    !["completed", "approved", "ready"].includes(String(enrich.status ?? "").toLowerCase())) {
+                    unenrichedRowIds.push(rowId);
+                }
+                const failed = cells.find((cell) => {
+                    const status = String(cell.status ?? "").toLowerCase();
+                    return (Boolean(stringValue(cell.error)) ||
+                        status === "error" ||
+                        status === "failed" ||
+                        status === "timeout");
+                });
+                if (failed) {
+                    failedRowIds.push(rowId);
+                    failureEvidence.push({
+                        rowId,
+                        error: stringValue(failed.error),
+                        statusReason: stringValue(failed.statusReason),
+                    });
+                }
+            }
+            const termination = record(repairing ? record(selected)?.termination : diagnostic?.termination);
+            const reason = stringValue(termination?.reason);
+            return {
+                limit,
+                orderedRowIds,
+                unenrichedRowIds,
+                failedRowIds,
+                failureEvidence,
+                termination: {
+                    reason: reason === "frontier_exhausted" ||
+                        reason === "scan_budget_exhausted" ||
+                        reason === "limit_reached"
+                        ? reason
+                        : "limit_reached",
+                    rowsChecked: typeof termination?.rowsChecked === "number"
+                        ? termination.rowsChecked
+                        : orderedRowIds.length,
+                    rowsRemaining: typeof termination?.rowsRemaining === "number"
+                        ? termination.rowsRemaining
+                        : null,
+                    hasMore: termination?.hasMore !== false,
+                },
+            };
+        },
+        async loadProviderPrompt({ provider, campaignOfferId }) {
+            if (provider !== "signal-discovery" &&
+                provider !== "apollo" &&
+                provider !== "sales-nav" &&
+                provider !== "prospeo") {
+                return null;
+            }
+            const promptPackage = owners.getProviderPrompt({
+                provider,
+                campaignOfferId,
+                confirmed: true,
+            });
+            return {
+                provider,
+                campaignOfferId,
+                promptPackage,
+                promptVersion: fingerprint(promptPackage),
+            };
+        },
+        async readLiveTableJob({ tableId }) {
+            const status = record(await owners.getPrepareCampaignMessagesStatus({
+                workspaceId: input.packet.scope.workspaceId,
+                campaignId: input.packet.scope.campaignId,
+                tableId,
+            }));
+            const state = String(status?.status ?? "").toLowerCase();
+            const activity = record(status?.activity);
+            const id = stringValue(status?.jobId) ?? stringValue(status?.id);
+            if (activity?.terminal === true)
+                return null;
+            // World-state omits an expired raw running row so the campaign remains
+            // inspectable. This status read is also the canonical revival owner,
+            // however, and the row still holds the table's active-job uniqueness
+            // fence. Surface that newer dispatch-boundary fact as queued so campaign
+            // work returns a bounded wait instead of attempting an impossible second
+            // start and repeating a no_effect receipt forever.
+            if (activity?.state === "expired_retryable") {
+                return id ? { id, kind: "message_generation", status: "queued" } : null;
+            }
+            return id && (state === "queued" || state === "running")
+                ? { id, kind: "message_generation", status: state }
+                : null;
+        },
+        async dispatchAuthority(request) {
+            const result = REFILL_V3_ACTION_RESULTS[request.action];
+            if (request.action === "enrich_bounded_sample") {
+                let reattached = false;
+                let prepared;
+                try {
+                    prepared = await owners.startPrepareCampaignMessages({
+                        workspaceId: request.scope.workspaceId,
+                        campaignId: request.scope.campaignId,
+                        tableId: request.scope.tableId,
+                        senderId: request.scope.senderId,
+                        actionType: input.packet.scope.actionType,
+                        approvalMode: "approve",
+                        autoContinue: true,
+                        requestSource: "refill_v3_continue",
+                        rowSelector: {
+                            type: "rowIds",
+                            rowIds: [...(request.rowIds ?? [])],
+                        },
+                    });
+                }
+                catch (error) {
+                    const conflict = activePreparationConflict(error);
+                    if (!conflict)
+                        throw error;
+                    const current = await owners.getPrepareCampaignMessagesStatus({
+                        workspaceId: request.scope.workspaceId,
+                        campaignId: request.scope.campaignId,
+                        tableId: request.scope.tableId,
+                        ...(conflict.activeJobId ? { jobId: conflict.activeJobId } : {}),
+                    });
+                    const currentRecord = record(current) ?? {};
+                    prepared = {
+                        ...currentRecord,
+                        jobId: stringValue(currentRecord.jobId) ?? conflict.activeJobId,
+                    };
+                    reattached = true;
+                }
+                const preparedRecord = record(prepared);
+                const delegation = Object.fromEntries(REFILL_V3_PREPARATION_REUSE_POINTS.map((point) => {
+                    const facts = {
+                        frontier: request.rowIds ?? [],
+                        remainingGapPassEvidence: input.packet.evidence.supply,
+                        serialBatchCap: null,
+                        totalRowBudget: null,
+                        replayKey: stringValue(preparedRecord?.requestHash) ??
+                            stringValue(preparedRecord?.jobId) ??
+                            request.idempotencyKey,
+                        lowPassGuard: "backend_owned",
+                        reclaimBehavior: "backend_owned",
+                    };
+                    return [point, facts[point]];
+                }));
+                return receipt({
+                    outcome: reattached ? "no_effect" : "applied",
+                    result,
+                    idempotencyKey: request.idempotencyKey,
+                    changedFields: reattached ? [] : ["campaignMessagePreparationJob"],
+                    after: prepared,
+                    preparationDelegation: delegation,
+                });
+            }
+            if (request.action === "rerun_errored_cells") {
+                const selected = new Set(request.rowIds ?? []);
+                const operations = new Map();
+                for (const row of diagnosticRows) {
+                    const rowId = stringValue(row.rowId);
+                    if (!rowId || !selected.has(rowId))
+                        continue;
+                    const cells = Array.isArray(row.cells)
+                        ? row.cells.flatMap((entry) => {
+                            const cell = record(entry);
+                            return cell ? [cell] : [];
+                        })
+                        : [];
+                    for (const cell of cells) {
+                        const role = cell.columnRole;
+                        const status = String(cell.status ?? "").toLowerCase();
+                        if (role !== "enrich" &&
+                            role !== "icpScore" &&
+                            role !== "generateMessage") {
+                            continue;
+                        }
+                        if (!stringValue(cell.error) &&
+                            status !== "error" &&
+                            status !== "failed" &&
+                            status !== "timeout") {
+                            continue;
+                        }
+                        const bucket = operations.get(role) ?? {
+                            rowIds: [],
+                            cellIds: [],
+                        };
+                        bucket.rowIds.push(rowId);
+                        const cellId = stringValue(cell.cellId);
+                        if (cellId)
+                            bucket.cellIds.push(cellId);
+                        operations.set(role, bucket);
+                    }
+                }
+                const action = {
+                    type: "rerun_errored_cells",
+                    ids: {
+                        campaignId: request.scope.campaignId,
+                        tableId: request.scope.tableId,
+                    },
+                    toolInput: {
+                        operations: [...operations.entries()].map(([columnRole, operation]) => ({
+                            columnRole,
+                            rowSelector: {
+                                type: "rowIds",
+                                rowIds: [...new Set(operation.rowIds)],
+                            },
+                            cellIds: [...new Set(operation.cellIds)],
+                        })),
+                    },
+                };
+                const executed = await owners.executeRerunErroredCellsPrimitive({
+                    action,
+                    workspaceId: request.scope.workspaceId,
+                });
+                return executed.executed
+                    ? receipt({
+                        outcome: "applied",
+                        result,
+                        idempotencyKey: request.idempotencyKey,
+                        changedFields: ["workflowTableCells"],
+                        after: executed,
+                    })
+                    : receipt({
+                        outcome: "refused",
+                        result,
+                        idempotencyKey: request.idempotencyKey,
+                        refusalReason: executed.reason,
+                    });
+            }
+            if (request.action === "regenerate_stale_messages") {
+                let reattached = false;
+                let prepared;
+                try {
+                    prepared = await owners.startPrepareCampaignMessages({
+                        workspaceId: request.scope.workspaceId,
+                        campaignId: request.scope.campaignId,
+                        tableId: request.scope.tableId,
+                        senderId: request.scope.senderId,
+                        actionType: input.packet.scope.actionType,
+                        approvalMode: "mark_ready",
+                        autoContinue: true,
+                        requestSource: "refill_v3_continue",
+                        rowSelector: request.rowIds?.length
+                            ? { type: "rowIds", rowIds: [...request.rowIds] }
+                            : { type: "needsGeneratedMessage" },
+                    });
+                }
+                catch (error) {
+                    const conflict = activePreparationConflict(error);
+                    if (!conflict)
+                        throw error;
+                    const current = await owners.getPrepareCampaignMessagesStatus({
+                        workspaceId: request.scope.workspaceId,
+                        campaignId: request.scope.campaignId,
+                        tableId: request.scope.tableId,
+                        ...(conflict.activeJobId ? { jobId: conflict.activeJobId } : {}),
+                    });
+                    const currentRecord = record(current) ?? {};
+                    prepared = {
+                        ...currentRecord,
+                        jobId: stringValue(currentRecord.jobId) ?? conflict.activeJobId,
+                    };
+                    reattached = true;
+                }
+                const preparedRecord = record(prepared);
+                const delegation = Object.fromEntries(REFILL_V3_PREPARATION_REUSE_POINTS.map((point) => {
+                    const facts = {
+                        frontier: request.rowIds ?? "needsGeneratedMessage",
+                        remainingGapPassEvidence: input.packet.evidence.supply,
+                        serialBatchCap: null,
+                        totalRowBudget: null,
+                        replayKey: stringValue(preparedRecord?.requestHash) ??
+                            stringValue(preparedRecord?.jobId) ??
+                            request.idempotencyKey,
+                        lowPassGuard: "backend_owned",
+                        reclaimBehavior: "backend_owned",
+                    };
+                    return [point, facts[point]];
+                }));
+                return receipt({
+                    outcome: reattached ? "no_effect" : "applied",
+                    result,
+                    idempotencyKey: request.idempotencyKey,
+                    changedFields: reattached ? [] : ["campaignMessagePreparationJob"],
+                    after: prepared,
+                    preparationDelegation: delegation,
+                });
+            }
+            if (request.action === "broaden_source_family" ||
+                (request.action === "patch_source_criteria" &&
+                    request.sourceCommand !== null) ||
+                (request.action === "record_source_frontier_exhausted" &&
+                    request.sourceCommand !== null)) {
+                if (!request.sourceCommand) {
+                    return receipt({
+                        outcome: "refused",
+                        result,
+                        idempotencyKey: request.idempotencyKey,
+                        refusalReason: "source_command_missing",
+                    });
+                }
+                const sourceOwners = owners.refillV3SourceFamilyOwners(request.scope.workspaceId);
+                const priorSourceFingerprint = input.packet.evidence.sourceLineage.at(-1) ?? null;
+                // The attention packet's sourceLineage is server-loaded from the
+                // bounded inventory owner. These inventory identities prove that
+                // provenance exists, but they are not themselves completed searches,
+                // so they must never enter the searched-negative set.
+                const lineage = priorSourceFingerprint === null
+                    ? null
+                    : input.packet.evidence.sourceLineage.map((sourceFingerprint) => ({
+                        campaignId: request.scope.campaignId,
+                        family: input.packet.evidence.leadSourceFamily,
+                        provider: input.packet.evidence.provider,
+                        sourceFingerprint,
+                        semanticFingerprint: sourceFingerprint,
+                        keywordBatch: null,
+                        postIds: null,
+                        importedCount: 0,
+                        yieldEvidence: null,
+                        observedAt: request.scope.date,
+                        searchCompleted: false,
+                    }));
+                const sourceOutcome = await owners.dispatchRefillV3SourceFamily({
+                    scope: {
+                        workspaceId: request.scope.workspaceId,
+                        campaignId: request.scope.campaignId,
+                        tableId: request.scope.tableId,
+                        sourceLeadListId: input.packet.evidence.selectedLeadListId ?? null,
+                        senderId: request.scope.senderId,
+                        date: request.scope.date,
+                        count: Math.max(0, input.packet.evidence.remainingGap),
+                        campaignVersion: request.scope.campaignVersion,
+                        evidenceFingerprint: request.scope.evidenceFingerprint,
+                        priorSourceFingerprint: priorSourceFingerprint ?? request.scope.evidenceFingerprint,
+                        idempotencyKey: request.idempotencyKey,
+                        providerSearchReference: input.packet.evidence.providerSearchReference ?? null,
+                    },
+                    action: request.action === "record_source_frontier_exhausted"
+                        ? "record_exhaustion"
+                        : request.action === "broaden_source_family"
+                            ? "broaden"
+                            : "continue",
+                    command: request.sourceCommand,
+                    owners: sourceOwners,
+                    lineage,
+                    observedFamily: input.packet.evidence.leadSourceFamily,
+                    activeJob: input.packet.evidence.activeJob,
+                    providerPromptPackage: request.providerPrompt?.promptPackage ?? null,
+                    candidateVerdicts: request.candidateVerdicts,
+                    exhaustionEvidence: request.exhaustionVerdict?.exhausted === true
+                        ? request.sourceCommand
+                            ? (chosen?.exhaustionEvidence ?? null)
+                            : null
+                        : null,
+                });
+                if (sourceOutcome.kind === "dispatched") {
+                    const changed = sourceOutcome.receipt.importedCount > 0;
+                    return receipt({
+                        outcome: changed ? "applied" : "no_effect",
+                        result,
+                        idempotencyKey: request.idempotencyKey,
+                        changedFields: changed ? ["sourceInventory"] : [],
+                        after: sourceOutcome.receipt,
+                    });
+                }
+                if (sourceOutcome.kind === "recorded_exhaustion") {
+                    return receipt({
+                        outcome: "no_effect",
+                        result,
+                        idempotencyKey: request.idempotencyKey,
+                        after: sourceOutcome.receipt,
+                    });
+                }
+                if (sourceOutcome.kind === "refused") {
+                    return receipt({
+                        outcome: "refused",
+                        result,
+                        idempotencyKey: request.idempotencyKey,
+                        refusalReason: `${sourceOutcome.refusal}:${sourceOutcome.detail}`,
+                    });
+                }
+                return receipt({
+                    outcome: sourceOutcome.failureClass === "uncertain"
+                        ? "uncertain"
+                        : "refused",
+                    result,
+                    idempotencyKey: request.idempotencyKey,
+                    refusalReason: sourceOutcome.detail,
+                });
+            }
+            if (request.action === "request_rubric_trial") {
+                const trial = await owners.broadenRubrics({
+                    type: "broaden_rubrics",
+                    ids: {
+                        campaignId: request.scope.campaignId,
+                        tableId: request.scope.tableId,
+                    },
+                    toolInput: {
+                        sampleRowIds: request.rowIds ?? [],
+                        candidateVerdicts: request.candidateVerdicts ?? [],
+                    },
+                }, request.scope.workspaceId);
+                return trial.status === "executed_and_reread"
+                    ? receipt({
+                        outcome: "applied",
+                        result,
+                        idempotencyKey: request.idempotencyKey,
+                        changedFields: ["campaignRubric"],
+                        after: trial.result,
+                    })
+                    : receipt({
+                        outcome: "refused",
+                        result,
+                        idempotencyKey: request.idempotencyKey,
+                        refusalReason: trial.refusalReason ?? "rubric_trial_refused",
+                    });
+            }
+            if (request.action === "record_source_frontier_exhausted") {
+                return receipt({
+                    outcome: "no_effect",
+                    result,
+                    idempotencyKey: request.idempotencyKey,
+                });
+            }
+            return receipt({
+                outcome: "refused",
+                result,
+                idempotencyKey: request.idempotencyKey,
+                refusalReason: "This decision needs the narrow campaign-edit authority and no complete edit packet was supplied.",
+            });
+        },
+        async reobserveExactSenderDates({ workspaceId, senderId, date }) {
+            const observation = await owners.getRefillV3WorldStateTool({
+                workspaceId,
+                scope: {
+                    kind: "exact_sender_dates",
+                    senderDates: [{ senderId, dates: [date] }],
+                },
+            });
+            return {
+                observed: true,
+                senderId,
+                date,
+                lanes: observation.rows
+                    .filter((row) => row.sender.id === senderId && row.date === date)
+                    .map((row) => row.lane),
+                evidenceFingerprint: fingerprint(observation),
+            };
+        },
+    };
+    return runRefillV3CampaignWork({
+        packet: input.packet,
+        output: input.output,
+        dependencies,
+    });
+}
+const DEFAULT_DEPENDENCIES = {
+    advance: advanceRefillV3Tool,
+    runCampaignWork: runRefillV3CampaignWorkWithProductionOwners,
+};
+export async function continueRefillV3(input, dependencies = DEFAULT_DEPENDENCIES) {
+    const workspaceId = normalizeExplicitWorkspaceId(input.workspaceId);
+    if (!workspaceId || workspaceId !== input.packet.scope.workspaceId) {
+        throw new Error("refill_v3_continue requires one exact workspace matching the server-issued packet.");
+    }
+    const advanceResult = await dependencies.advance({
+        workspaceId,
+        scope: input.scope,
+        ...(input.yolo === undefined ? {} : { yolo: input.yolo }),
+    });
+    if (advanceResult.kind !== "campaign_attention_required") {
+        return { kind: "world_advanced", advanceResult };
+    }
+    if (!samePacket(input.packet, advanceResult.packet)) {
+        return { kind: "attention_refresh_required", advanceResult };
+    }
+    const outcome = await dependencies.runCampaignWork({
+        packet: advanceResult.packet,
+        output: input.decision,
+    });
+    return { kind: "campaign_work_completed", outcome };
+}
+export async function continueRefillV3Tool(input) {
+    const workspaceId = normalizeExplicitWorkspaceId(input.workspaceId);
+    const packet = decodeRefillV3ContinuePacket(input.packet);
+    if (!workspaceId || !packet) {
+        throw new Error("refill_v3_continue requires an exact workspaceId and a valid server-issued attention packet.");
+    }
+    return continueRefillV3({
+        workspaceId,
+        scope: input.scope,
+        ...(input.yolo === undefined ? {} : { yolo: input.yolo }),
+        packet,
+        decision: input.decision,
+    });
+}
+import { getPrepareCampaignMessagesStatus, startPrepareCampaignMessages, } from "./campaign-message-preparation.js";
+import { selectCampaignCells, selectRepairableCampaignCells, } from "./campaign-processing.js";
+import { getProviderPrompt } from "./leads.js";
+import { broadenRubrics, executeRerunErroredCellsPrimitive, refillV3SourceFamilyOwners, } from "./refill-executors.js";