@sellable/mcp 0.1.188 → 0.1.190

package/agents/post-find-leads-message-scout.md

@@ -37,13 +37,14 @@ the branch input.
 
 ## Required First Steps
 
-1. Load the full long-form generate-messages prompt:
+1. Load the compact normal-path message prompt:
 
-   `get_subskill_prompt({ subskillName: "generate-messages", offset, limit })`
-   until `hasMore` is false.
+   `get_subskill_prompt({ subskillName: "generate-messages-compact" })`
 
-2. Use that prompt as the drafting contract. Do not use create-campaign
-   safety/checklist instructions as a substitute for the full prompt.
+2. Use that prompt as the drafting contract. Load
+   `generate-messages-compact/references/examples-critique-revision.md` only for
+   critique, revision, or close-call examples. Do not use create-campaign
+   safety/checklist instructions as a substitute for the message prompt.
 3. Draft only from the campaign brief, selected source context, and initial
    campaign-table execution slice rows supplied by the parent.
 4. Keep the work provisional until the user chooses `Use Template` in Messages.
@@ -56,7 +57,7 @@ Return the following to the parent thread:
 - token fill rules and fallbacks
 - one rendered good-fill sample for a plausible passing campaign-table row
 - one omit/fallback sample when the row signal is not safe
-- pass/fail notes against the generate-messages quality gates
+- pass/fail notes against the generate-messages-compact quality gates
 - compact runtime status: `ready`, `blocked`, `retry-needed`, or `stale`
 - basis token containing campaign revision/updatedAt, brief hash,
   `selectedLeadListId`, `workflowTableId`, execution-slice row ids/hash, filter
@@ -136,7 +137,7 @@ enablement`, or omit it.
 
 Return a concise status with:
 
-- prompt basis loaded: `generate-messages`
+- prompt basis loaded: `generate-messages-compact`
 - live campaign basis used
 - proposed template
 - token fill rules/fallbacks

package/agents/registry.json

@@ -197,7 +197,7 @@
       "kind": "post-find-leads-scout",
       "promptFile": "post-find-leads-message-scout.md",
       "displayName": "Message Draft Builder",
-      "target": "generate-messages",
+      "target": "generate-messages-compact",
       "inputs": [
         "campaignId",
         "campaignBrief",
@@ -225,7 +225,7 @@
         ]
       },
       "claude": {
-        "description": "Use proactively as Message Draft Builder after confirm_lead_list imports a non-empty bounded review batch; load the full generate-messages prompt and draft only from scoped campaign/tool state.",
+        "description": "Use proactively as Message Draft Builder after confirm_lead_list imports a non-empty bounded review batch; load generate-messages-compact and draft only from scoped campaign/tool state.",
         "model": "inherit",
         "background": true,
         "maxTurns": 10,

package/dist/server.js

@@ -6,6 +6,7 @@ import { getAuthStatus } from "./tools/auth.js";
 import { handleAddColumn, handleCommitBlueprint, } from "./tools/blueprint-commit.js";
 import { bootstrapCreateCampaign } from "./tools/bootstrap.js";
 import { createCampaign, getCampaign, getCampaignMessagesPreview, getCampaigns, pauseCampaign, startCampaign, updateCampaign, updateCampaignBrief, } from "./tools/campaigns.js";
+import { getCampaignTableSchema, queueCampaignCells, reviseMessageTemplateAndRerun, selectCampaignCells, waitForCampaignProcessing, } from "./tools/campaign-processing.js";
 import { queueCells, updateCell } from "./tools/cells.js";
 import { handleStartCliLogin, handleWaitForCliLogin, } from "./tools/cli-login.js";
 import { getCampaignContext, hydrateCampaignContextFromCampaign, markCampaignContextDirty, } from "./tools/context.js";
@@ -160,6 +161,27 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "get_campaign_messages_preview":
                 result = await getCampaignMessagesPreview(args);
                 break;
+            case "get_campaign_table_schema":
+                result = await getCampaignTableSchema(args);
+                break;
+            case "select_campaign_cells":
+                result = await selectCampaignCells(args);
+                break;
+            case "queue_campaign_cells":
+                result = await queueCampaignCells(args);
+                if (args?.campaignId) {
+                    markCampaignContextDirty(args.campaignId, "queue_campaign_cells");
+                }
+                break;
+            case "wait_for_campaign_processing":
+                result = await waitForCampaignProcessing(args);
+                break;
+            case "revise_message_template_and_rerun":
+                result = await reviseMessageTemplateAndRerun(args);
+                if (args?.campaignId) {
+                    markCampaignContextDirty(args.campaignId, "revise_message_template_and_rerun");
+                }
+                break;
             case "create_campaign":
                 result = await createCampaign(args);
                 if (result?.id)

package/dist/tools/campaign-processing.d.ts

@@ -0,0 +1,383 @@
+type ColumnRole = "enrich" | "passesRubric" | "icpScore" | "generateMessage" | "approved";
+type RowSelector = {
+    type: "reviewBatch";
+    basisHash?: string;
+} | {
+    type: "rowIds";
+    rowIds: string[];
+} | {
+    type: "passedRows";
+    limit?: number;
+} | {
+    type: "needsGeneratedMessage";
+    limit?: number;
+} | {
+    type: "staleGeneratedMessages";
+    limit?: number;
+};
+type SchemaInput = {
+    campaignId?: string;
+    tableId?: string;
+};
+type SelectInput = SchemaInput & {
+    columnRole: ColumnRole;
+    rowSelector: RowSelector;
+    limit?: number;
+};
+type QueueInput = SelectInput & {
+    forceRerun?: boolean;
+    reason?: string;
+};
+type WaitInput = SchemaInput & {
+    minPassedCount?: number;
+    minGeneratedMessages?: number;
+    templateRevision?: "current" | string;
+    timeoutMs?: number;
+    intervalMs?: number;
+};
+type ReviseTemplateInput = SchemaInput & {
+    campaignId: string;
+    templateMarkdown?: string;
+    approvedMessageTemplate?: string;
+    rowSelector?: RowSelector;
+    limit?: number;
+};
+type CampaignProcessingSchemaResponse = {
+    campaignId: string | null;
+    tableId: string;
+    rowCount: number;
+    currentApprovedBriefHash: string | null;
+    reviewBatch?: {
+        rowIds?: string[];
+        rowCount?: number;
+        basisHash?: string;
+    };
+    warnings?: string[];
+};
+type WorkflowTableStats = {
+    tableId: string;
+    totalRows: number;
+    messagesCount?: number;
+    generatedMessagesCount?: number;
+    currentRevisionGeneratedMessagesCount?: number;
+    staleGeneratedMessagesCount?: number;
+    generatedWithoutPassCount?: number;
+    currentTemplateRevisionHash?: string | null;
+    processingCount?: number;
+    queuedCount?: number;
+    cancellableCount?: number;
+    failedCount?: number;
+    needsApprovalCount?: number;
+    passRate?: {
+        completed: number;
+        passed: number;
+        pending?: number;
+    };
+};
+export declare const campaignProcessingToolDefinitions: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            campaignId: {
+                type: string;
+            };
+            tableId: {
+                type: string;
+            };
+            columnRole?: undefined;
+            rowSelector?: undefined;
+            limit?: undefined;
+            forceRerun?: undefined;
+            reason?: undefined;
+            minPassedCount?: undefined;
+            minGeneratedMessages?: undefined;
+            templateRevision?: undefined;
+            timeoutMs?: undefined;
+            intervalMs?: undefined;
+            templateMarkdown?: undefined;
+            approvedMessageTemplate?: undefined;
+        };
+        additionalProperties: boolean;
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            campaignId: {
+                type: string;
+            };
+            tableId: {
+                type: string;
+            };
+            columnRole: {
+                type: string;
+                enum: string[];
+            };
+            rowSelector: {
+                type: string;
+                properties: {
+                    type: {
+                        type: string;
+                        enum: string[];
+                    };
+                    basisHash: {
+                        type: string;
+                    };
+                    rowIds: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                    limit: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            limit: {
+                type: string;
+            };
+            forceRerun?: undefined;
+            reason?: undefined;
+            minPassedCount?: undefined;
+            minGeneratedMessages?: undefined;
+            templateRevision?: undefined;
+            timeoutMs?: undefined;
+            intervalMs?: undefined;
+            templateMarkdown?: undefined;
+            approvedMessageTemplate?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            campaignId: {
+                type: string;
+            };
+            tableId: {
+                type: string;
+            };
+            columnRole: {
+                type: string;
+                enum: string[];
+            };
+            rowSelector: {
+                type: string;
+                properties: {
+                    type: {
+                        type: string;
+                        enum: string[];
+                    };
+                    basisHash: {
+                        type: string;
+                    };
+                    rowIds: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                    limit: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            forceRerun: {
+                type: string;
+            };
+            limit: {
+                type: string;
+            };
+            reason: {
+                type: string;
+            };
+            minPassedCount?: undefined;
+            minGeneratedMessages?: undefined;
+            templateRevision?: undefined;
+            timeoutMs?: undefined;
+            intervalMs?: undefined;
+            templateMarkdown?: undefined;
+            approvedMessageTemplate?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            campaignId: {
+                type: string;
+            };
+            tableId: {
+                type: string;
+            };
+            minPassedCount: {
+                type: string;
+            };
+            minGeneratedMessages: {
+                type: string;
+            };
+            templateRevision: {
+                type: string;
+                description: string;
+            };
+            timeoutMs: {
+                type: string;
+            };
+            intervalMs: {
+                type: string;
+            };
+            columnRole?: undefined;
+            rowSelector?: undefined;
+            limit?: undefined;
+            forceRerun?: undefined;
+            reason?: undefined;
+            templateMarkdown?: undefined;
+            approvedMessageTemplate?: undefined;
+        };
+        additionalProperties: boolean;
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            campaignId: {
+                type: string;
+            };
+            tableId: {
+                type: string;
+            };
+            templateMarkdown: {
+                type: string;
+            };
+            approvedMessageTemplate: {
+                type: string;
+            };
+            rowSelector: {
+                type: string;
+                properties: {
+                    type: {
+                        type: string;
+                        enum: string[];
+                    };
+                    rowIds: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                    limit: {
+                        type: string;
+                    };
+                    basisHash?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            limit: {
+                type: string;
+            };
+            columnRole?: undefined;
+            forceRerun?: undefined;
+            reason?: undefined;
+            minPassedCount?: undefined;
+            minGeneratedMessages?: undefined;
+            templateRevision?: undefined;
+            timeoutMs?: undefined;
+            intervalMs?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+})[];
+export declare function getCampaignTableSchema(input: SchemaInput): Promise<CampaignProcessingSchemaResponse>;
+export declare function selectCampaignCells(input: SelectInput): Promise<unknown>;
+export declare function queueCampaignCells(input: QueueInput): Promise<unknown>;
+export declare function reviseMessageTemplateAndRerun(input: ReviseTemplateInput): Promise<unknown>;
+export declare function waitForCampaignProcessing(input: WaitInput): Promise<{
+    ready: boolean;
+    reason: string;
+    attempts: number;
+    elapsedMs: number;
+    tableId: string;
+    pollKey: string;
+    requestedTemplateRevision: string;
+    currentTemplateRevisionHash: string;
+    guidance: string;
+    stats: WorkflowTableStats;
+    floors?: undefined;
+    result?: undefined;
+    warning?: undefined;
+    partialResult?: undefined;
+} | {
+    ready: boolean;
+    attempts: number;
+    elapsedMs: number;
+    tableId: string;
+    pollKey: string;
+    floors: {
+        minPassedCount: number | null;
+        minGeneratedMessages: number | null;
+        templateRevision: string | null;
+    };
+    result: {
+        passedCount: number;
+        generatedMessagesCount: number;
+        currentRevisionGeneratedMessagesCount: number;
+        staleGeneratedMessagesCount: number;
+        generatedWithoutPassCount: number;
+        currentTemplateRevisionHash: string | null;
+    };
+    stats: WorkflowTableStats;
+    reason?: undefined;
+    requestedTemplateRevision?: undefined;
+    currentTemplateRevisionHash?: undefined;
+    guidance?: undefined;
+    warning?: undefined;
+    partialResult?: undefined;
+} | {
+    ready: boolean;
+    reason: string;
+    attempts: number;
+    elapsedMs: number;
+    tableId: string;
+    pollKey: string;
+    warning: string | undefined;
+    partialResult: {
+        passedCount: number;
+        generatedMessagesCount: number;
+        currentRevisionGeneratedMessagesCount: number;
+        staleGeneratedMessagesCount: number;
+        generatedWithoutPassCount: number;
+        currentTemplateRevisionHash: string | null;
+        passFloorMet: boolean;
+        generatedFloorMet: boolean;
+    };
+    guidance: string;
+    stats: WorkflowTableStats | null;
+    requestedTemplateRevision?: undefined;
+    currentTemplateRevisionHash?: undefined;
+    floors?: undefined;
+    result?: undefined;
+}>;
+export {};