@sellable/mcp 0.1.372 → 0.1.373

package/dist/api.d.ts

@@ -2,6 +2,12 @@ export interface ApiResponse<T> {
     data: T;
     error?: string;
 }
+export interface DownloadToFileResult {
+    path: string;
+    bytes: number;
+    contentType: string | null;
+    status: number;
+}
 export declare class SellableApiError extends Error {
     status: number;
     body: string;
@@ -15,6 +21,7 @@ export declare class SellableApi {
     private request;
     get<T>(path: string): Promise<T>;
     getText(path: string): Promise<string>;
+    downloadToFile(requestPath: string, destinationPath: string): Promise<DownloadToFileResult>;
     post<T>(path: string, body?: object): Promise<T>;
     put<T>(path: string, body?: object): Promise<T>;
     patch<T>(path: string, body?: object): Promise<T>;

package/dist/api.js

@@ -1,4 +1,9 @@
 import { getConfig, getConfigPath } from "./auth.js";
+import { createWriteStream } from "node:fs";
+import { mkdir, rename, rm, stat } from "node:fs/promises";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
 export class SellableApiError extends Error {
     status;
     body;
@@ -61,6 +66,33 @@ export class SellableApi {
         const response = await this.requestResponse("GET", path);
         return response.text();
     }
+    async downloadToFile(requestPath, destinationPath) {
+        const response = await this.requestResponse("GET", requestPath);
+        if (!response.body) {
+            throw new SellableApiError(response.status, "Response body was empty for file download");
+        }
+        await mkdir(path.dirname(destinationPath), { recursive: true });
+        const tempPath = `${destinationPath}.tmp-${process.pid}-${Date.now()}`;
+        let completed = false;
+        try {
+            const nodeStream = Readable.fromWeb(response.body);
+            await pipeline(nodeStream, createWriteStream(tempPath, { flags: "wx" }));
+            const fileStat = await stat(tempPath);
+            await rename(tempPath, destinationPath);
+            completed = true;
+            return {
+                path: destinationPath,
+                bytes: fileStat.size,
+                contentType: response.headers.get("content-type"),
+                status: response.status,
+            };
+        }
+        finally {
+            if (!completed) {
+                await rm(tempPath, { force: true }).catch(() => undefined);
+            }
+        }
+    }
     async post(path, body) {
         return this.request("POST", path, body);
     }

package/dist/server.js

@@ -48,6 +48,7 @@ import { exportTableCsv, listTables } from "./tools/tables.js";
 import { handleVerifyTableRow } from "./tools/verify-row.js";
 import { sanitizeWatchUrlsForMcpResult } from "./tools/watch-url-security.js";
 import { getCampaignWaterfall, setCampaignWaterfallOrder, } from "./tools/waterfalls.js";
+import { exportWorkspaceCsv } from "./tools/workspace-export.js";
 import { addTeammate, createWorkspace, getActiveWorkspace, listWorkspaces, setActiveWorkspace, } from "./tools/workspaces.js";
 import { checkForUpdates, logUpdateNotice } from "./update-check.js";
 const server = new Server({
@@ -75,8 +76,9 @@ function markEvergreenSetupCampaignsDirty(args) {
     const campaignIds = new Set();
     const bindings = Array.isArray(args.bindings) ? args.bindings : [];
     for (const binding of bindings) {
-        if (!binding || typeof binding !== "object" || Array.isArray(binding))
+        if (!binding || typeof binding !== "object" || Array.isArray(binding)) {
             continue;
+        }
         const campaignId = binding.campaignId;
         if (typeof campaignId === "string" && campaignId.trim()) {
             campaignIds.add(campaignId.trim());
@@ -84,8 +86,9 @@ function markEvergreenSetupCampaignsDirty(args) {
     }
     const receipts = Array.isArray(args.receipts) ? args.receipts : [];
     for (const receipt of receipts) {
-        if (!receipt || typeof receipt !== "object" || Array.isArray(receipt))
+        if (!receipt || typeof receipt !== "object" || Array.isArray(receipt)) {
             continue;
+        }
         const campaignId = receipt.campaignId;
         if (typeof campaignId === "string" && campaignId.trim()) {
             campaignIds.add(campaignId.trim());
@@ -388,6 +391,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "export_table_csv":
                 result = await exportTableCsv(args);
                 break;
+            case "export_workspace_csv":
+                result = await exportWorkspaceCsv(args);
+                break;
             case "search_inbox_threads":
                 result = await searchInboxThreads(args);
                 break;

package/dist/tools/registry.js

@@ -42,6 +42,7 @@ import { setupEvergreenCampaignsToolDefinitions } from "./setup-evergreen-campai
 import { tableToolDefinitions } from "./tables.js";
 import { verifyRowToolDefinitions } from "./verify-row.js";
 import { waterfallToolDefinitions } from "./waterfalls.js";
+import { workspaceExportToolDefinitions } from "./workspace-export.js";
 import { workspaceToolDefinitions } from "./workspaces.js";
 export const allTools = [
     ...campaignToolDefinitions,
@@ -83,6 +84,7 @@ export const allTools = [
     ...engageMemoryToolDefinitions,
     ...sequencerToolDefinitions,
     ...tableToolDefinitions,
+    ...workspaceExportToolDefinitions,
     ...columnSchemaToolDefinitions,
     ...blueprintCommitToolDefinitions,
     ...columnUpdateToolDefinitions,

package/dist/tools/setup-evergreen-campaigns.d.ts

@@ -13,7 +13,7 @@ type SetupEvergreenCampaignsInput = {
     }>;
     planRevision?: string;
     selectedActionIds?: string[];
-    receipts?: unknown[];
+    receipts?: Array<Record<string, unknown>>;
 };
 export declare const setupEvergreenCampaignsToolDefinitions: {
     name: string;

package/dist/tools/setup-evergreen-campaigns.js

@@ -6,7 +6,7 @@ async function postSetupEvergreenCampaigns(body) {
 export const setupEvergreenCampaignsToolDefinitions = [
     {
         name: "setup_evergreen_campaigns",
-        description: "Evergreen campaign setup plan/verify command. Use plan mode first to inspect exact workspace/sender/campaign/table/source state and receive immutable lane packets. `selectedSenderIds` is a legacy shorthand for both scopes; prefer `postEngagerSenderIds` for the Post Engagers sender scope and `sharedSenderIds` for the shared lane sender scope when they differ. The command plans one Post Engagers lane per post-engager sender plus shared Signal Discovery and Shared Cold Fallback lanes for the shared sender set. yolo is only a parent-skill auto-execution hint for safe lane packets; this backend command remains read-only in plan mode and verifies receipts in verify mode. Each lane packet includes workerDispatch with acceptedRuntimes, rejectedRuntimes, requiresVisibleThreadOrDurableReceipt, and receiptArtifactHint; `multi_agent_v1.spawn_agent`/opaque spawn_agent is not accepted for mutating command proof unless the parent has visible thread or durable receipt proof. When safe-yolo needs normal setup work, the parent skill may ask for bounded delegated approval: one approval over the current planRevision, selected action ids, caps, allowed side-effect classes, and stop conditions lets lane workers execute without per-substep approval while staying inside that packet. Lane workers must explicitly load and use the installed `$sellable:create-campaign` wrapper as the nested workflow entrypoint, then load `create-campaign-v2` and `create-campaign-v2/core/flow.v2.json`; they must execute creation, source import, create-campaign workflow steps, generate-messages, sequence attachment, pause_campaign review-state transition when the current table is still DRAFT, and review readiness through that existing create-campaign workflow/subskills, then return receipts here for verification. Customer-visible verify receipts must set status:'succeeded' or status:'completed' and must include createCampaignStepReceipt with setupPlanCall, createCampaignWorkflowReceipt, campaignBriefReceipt, sourceDecisionReceipt, filterDecisionReceipt, messageDraftingReceipt, reviewBatchReceipt, sequenceReceipt, and verifyCall nested inside createCampaignStepReceipt; top-level-only copies of those objects are not enough. setupPlanCall must use canonical keys: planRevision, actionId, laneKey, workspaceId, senderIds, campaignId, tableId, createIntent. Do not use laneActionId, lanePacketActionId, delegatedPlanRevision, delegatedActionId, or requestedCall text as a substitute for those canonical fields. createCampaignWorkflowReceipt must include skillCommand:'$sellable:create-campaign', skillName:'create-campaign', wrapperSkillLoaded:true, workflowPromptName:'create-campaign-v2', workflowPromptLoadedToHasMoreFalse:true, workflowAssetPath:'create-campaign-v2/core/flow.v2.json', workflowAssetLoaded:true, workerRuntime, workerThreadId or receiptArtifactPath, durableReceiptWritten when using a receipt file, and notAdHoc:true. messageDraftingReceipt must use statusSource:'branch' or statusSource:'packaged-generate-messages-worker' and include proof that generate-messages was loaded, start_campaign_message_preparation/get_campaign_message_preparation_status ran when the packaged worker path is used, validationResult:'passed', a passed qualityReview, and at least 3 concrete sampleMessages with rowId, generatedMessageText, verdict, and issues; Do not substitute `message` for `generatedMessageText`; Do not substitute `passVerdict` for `verdict`. Before writing durable receipts, run a receipt self-check: top-level `planRevision`, `actionId`, `laneKey`, `laneType`, `workspaceId`, and `senderIds` must exist; if the self-check fails, fix the receipt before ending. Use start_campaign_message_preparation with approvalMode:\"mark_ready\" only for evergreen setup. Never call `start_campaign_message_preparation` with `approvalMode:\"approve\"`; approve exactly one semantic Approved cell through select_campaign_cells/update_cell and final proof must show approvedGeneratedMessageCount exactly 1. Shared Cold Fallback samples with a standalone name followed by 'Hey there' are rejected. This command does not launch campaigns, does not schedule sends, does not assign scheduler-owned send fields, does not raw-write campaign status, does not archive/delete cleanup targets, and does not spend paid credits.",
+        description: "Evergreen campaign setup plan/verify command. Use plan mode first to inspect exact workspace/sender/campaign/table/source state and receive immutable lane packets. `selectedSenderIds` is a legacy shorthand for both scopes; prefer `postEngagerSenderIds` for the Post Engagers sender scope and `sharedSenderIds` for the shared lane sender scope when they differ. The command plans one Post Engagers lane per post-engager sender plus shared Signal Discovery and Shared Cold Fallback lanes for the shared sender set. yolo is only a parent-skill auto-execution hint for safe lane packets; this backend command remains read-only in plan mode and verifies receipts in verify mode. Each lane packet includes workerDispatch with acceptedRuntimes, rejectedRuntimes, requiresVisibleThreadOrDurableReceipt, and receiptArtifactHint; `multi_agent_v1.spawn_agent`/opaque spawn_agent is not accepted for mutating command proof unless the parent has visible thread or durable receipt proof. In local Codex, call `codex_app.list_projects` first, then `codex_app.create_thread` with a local project target; do not create a worktree for lane execution. When safe-yolo needs normal setup work, the parent skill may ask for bounded delegated approval: one approval over the current planRevision, selected action ids, caps, allowed side-effect classes, and stop conditions lets lane workers execute without per-substep approval while staying inside that packet. Lane workers must explicitly load and use the installed `$sellable:create-campaign` wrapper as the nested workflow entrypoint, then load `create-campaign-v2` and `create-campaign-v2/core/flow.v2.json`; they must execute creation, source import, create-campaign workflow steps, generate-messages, sequence attachment, pause_campaign review-state transition when the current table is still DRAFT, and review readiness through that existing create-campaign workflow/subskills, then return receipts here for verification. Customer-visible verify receipts must set status:'succeeded' or status:'completed'; status:'passed', status:'pass', and status:'passed_with_warnings' are rejected as primary success statuses. Receipts must include createCampaignStepReceipt with setupPlanCall, createCampaignWorkflowReceipt, campaignBriefReceipt, sourceDecisionReceipt, filterDecisionReceipt, messageDraftingReceipt, reviewBatchReceipt, sequenceReceipt, and verifyCall nested inside createCampaignStepReceipt; top-level-only copies of those objects are not enough and are not promoted by verify. setupPlanCall must use canonical keys: planRevision, actionId, laneKey, workspaceId, senderIds, campaignId, tableId, createIntent. Do not use laneActionId, lanePacketActionId, delegatedPlanRevision, delegatedActionId, or requestedCall text as a substitute for those canonical fields. createCampaignWorkflowReceipt must include skillCommand:'$sellable:create-campaign', skillName:'create-campaign', wrapperSkillLoaded:true, workflowPromptName:'create-campaign-v2', workflowPromptLoadedToHasMoreFalse:true, workflowAssetPath:'create-campaign-v2/core/flow.v2.json', workflowAssetLoaded:true, workerRuntime, workerThreadId or receiptArtifactPath, durableReceiptWritten when using a receipt file, and notAdHoc:true. messageDraftingReceipt must use exactly statusSource:'branch' or statusSource:'packaged-generate-messages-worker'; descriptive aliases such as statusSource:'package-readback-local-thread' are rejected. It must include proof that generate-messages was loaded, start_campaign_message_preparation/get_campaign_message_preparation_status ran when the packaged worker path is used, validationResult:'passed', a passed qualityReview, and at least 3 concrete sampleMessages with rowId, generatedMessageText, verdict, and issues; Do not substitute `message` for `generatedMessageText`; Do not substitute `passVerdict` for `verdict`. Before writing durable receipts, run a receipt self-check: top-level `planRevision`, `actionId`, `laneKey`, `laneType`, `workspaceId`, and `senderIds` must exist; if the self-check fails, fix the receipt before ending. Use start_campaign_message_preparation with approvalMode:\"mark_ready\" only for evergreen setup. Never call `start_campaign_message_preparation` with `approvalMode:\"approve\"`; approve exactly one semantic Approved cell through select_campaign_cells/update_cell and final proof must show approvedGeneratedMessageCount exactly 1. Shared Cold Fallback samples with a standalone name followed by 'Hey there' are rejected. This command does not launch campaigns, does not schedule sends, does not assign scheduler-owned send fields, does not raw-write campaign status, does not archive/delete cleanup targets, and does not spend paid credits.",
         inputSchema: {
             type: "object",
             properties: {
@@ -75,7 +75,7 @@ export const setupEvergreenCampaignsToolDefinitions = [
                     type: "array",
                     maxItems: 20,
                     items: { type: "object" },
-                    description: "Required for verify. Structured lane worker receipts from create-campaign/source/message/sequence execution. Customer-visible lanes must use status:'succeeded' or status:'completed' and include createCampaignStepReceipt with setupPlanCall, createCampaignWorkflowReceipt, campaignBriefReceipt, sourceDecisionReceipt, filterDecisionReceipt, messageDraftingReceipt, reviewBatchReceipt, sequenceReceipt, and verifyCall nested inside createCampaignStepReceipt. setupPlanCall must use canonical keys: planRevision, actionId, laneKey, workspaceId, senderIds, campaignId, tableId, createIntent; do not use laneActionId, lanePacketActionId, delegatedPlanRevision, or delegatedActionId aliases. createCampaignWorkflowReceipt proves the lane worker loaded `$sellable:create-campaign`, `create-campaign-v2`, and `create-campaign-v2/core/flow.v2.json`; it must also include a visible workerThreadId or durable receiptArtifactPath with durableReceiptWritten:true. messageDraftingReceipt.sampleMessages must use rowId, generatedMessageText, verdict, and issues. top-level-only proof copies are not enough.",
+                    description: "Required for verify. Structured lane worker receipts from create-campaign/source/message/sequence execution. Customer-visible lanes must use status:'succeeded' or status:'completed'; status:'passed', status:'pass', and status:'passed_with_warnings' are rejected. Receipts must include createCampaignStepReceipt with setupPlanCall, createCampaignWorkflowReceipt, campaignBriefReceipt, sourceDecisionReceipt, filterDecisionReceipt, messageDraftingReceipt, reviewBatchReceipt, sequenceReceipt, and verifyCall nested inside createCampaignStepReceipt. setupPlanCall must use canonical keys: planRevision, actionId, laneKey, workspaceId, senderIds, campaignId, tableId, createIntent; do not use laneActionId, lanePacketActionId, delegatedPlanRevision, or delegatedActionId aliases. createCampaignWorkflowReceipt proves the lane worker loaded `$sellable:create-campaign`, `create-campaign-v2`, and `create-campaign-v2/core/flow.v2.json`; it must also include a visible workerThreadId or durable receiptArtifactPath with durableReceiptWritten:true. messageDraftingReceipt.statusSource must be exactly 'branch' or 'packaged-generate-messages-worker'; messageDraftingReceipt.sampleMessages must use rowId, generatedMessageText, verdict, and issues. top-level-only proof copies are not enough.",
                 },
             },
             required: [],

package/dist/tools/workspace-export.d.ts

@@ -0,0 +1,110 @@
+export type WorkspaceExportDataset = "people" | "events";
+export type WorkspaceExportIntent = "reached_out_people" | "people_and_events" | "outreach_event_log" | "dashboard_messages" | "connections_sent";
+type WorkspaceExportActionType = "INVITE" | "DM" | "INMAIL_OPEN" | "INMAIL_CLOSED" | "VIEW_PROFILE" | "COMMENT";
+export interface ExportWorkspaceCsvInput {
+    exportType?: "outreach";
+    exportIntent?: WorkspaceExportIntent;
+    datasets?: WorkspaceExportDataset[];
+    actionTypes?: WorkspaceExportActionType[];
+    outputDir?: string;
+    fromSentAt?: string;
+    toSentAt?: string;
+    campaignIds?: string[];
+    tableIds?: string[];
+}
+export declare const workspaceExportToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            exportType: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            exportIntent: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            datasets: {
+                type: string;
+                items: {
+                    type: string;
+                    enum: string[];
+                };
+                description: string;
+            };
+            actionTypes: {
+                type: string;
+                items: {
+                    type: string;
+                    enum: string[];
+                };
+                description: string;
+            };
+            outputDir: {
+                type: string;
+                description: string;
+            };
+            fromSentAt: {
+                type: string;
+                description: string;
+            };
+            toSentAt: {
+                type: string;
+                description: string;
+            };
+            campaignIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            tableIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+        };
+        required: never[];
+        additionalProperties: boolean;
+    };
+}[];
+export declare function exportWorkspaceCsv(input?: ExportWorkspaceCsvInput): Promise<{
+    status: string;
+    outputDir: string;
+    manifestPath: string;
+    datasets: {
+        dataset: WorkspaceExportDataset;
+        path: string;
+        rows: number;
+        bytes: number;
+        status: "complete" | "failed";
+    }[];
+    exportCutoff: string;
+    exportIntent: WorkspaceExportIntent | null;
+    intentDescription: string | null;
+    countDefinitions: {
+        reachedOutPeople: string;
+        outreachEvents: string;
+        dashboardMessagesSent: string;
+        connectionsSent: string;
+        profileViews: string;
+    };
+    counts: Record<string, unknown>;
+    workspace: {
+        id?: string;
+        name?: string | null;
+    };
+    skipped: string[];
+    failures: {
+        dataset: WorkspaceExportDataset;
+        error: string;
+    }[];
+}>;
+export {};

package/dist/tools/workspace-export.js

@@ -0,0 +1,465 @@
+import { parse } from "csv-parse";
+import { createReadStream } from "node:fs";
+import { lstat, mkdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { getApi } from "../api.js";
+import { getConfig } from "../auth.js";
+const MAX_FILTER_IDS = 100;
+const MAX_QUERY_LENGTH = 8000;
+export const workspaceExportToolDefinitions = [
+    {
+        name: "export_workspace_csv",
+        description: "Export active-workspace outreach CSVs to local files on the MCP host. " +
+            "Use exportIntent to disambiguate counts before exporting: " +
+            "`reached_out_people` means one deduped row per unique prospect who received an actual contact attempt (invite, DM, open InMail, or paid/closed InMail) and is the right choice for 'everyone we reached out to'; " +
+            "`dashboard_messages` means message events only (DMs + InMails), matching the dashboard Messages Sent card; " +
+            "`connections_sent` means invite events only; " +
+            "`outreach_event_log` means one row per action event for audit/reconciliation; " +
+            "`people_and_events` exports the reached-out people CSV plus matching contact event rows. " +
+            "If the user asks for 'sent', 'reached out', or cites conflicting dashboard/export numbers, ask which intent they want before calling the tool. " +
+            "Requires a valid Sellable API key plus active workspace; run list_workspaces and set_active_workspace first if needed. " +
+            "The manifest includes file paths, counts, filters, package/runtime metadata, and skipped/deferred scope notes. " +
+            "CSV files may contain prospect and outreach metadata, so store them appropriately.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                exportType: {
+                    type: "string",
+                    enum: ["outreach"],
+                    description: "Export family. Phase 70 supports outreach only.",
+                },
+                exportIntent: {
+                    type: "string",
+                    enum: [
+                        "reached_out_people",
+                        "people_and_events",
+                        "outreach_event_log",
+                        "dashboard_messages",
+                        "connections_sent",
+                    ],
+                    description: "Recommended semantic export. Use reached_out_people for 'everyone we reached out to'; dashboard_messages for the dashboard Messages Sent card; connections_sent for invites; outreach_event_log for audit rows; people_and_events for both reached people and matching contact events.",
+                },
+                datasets: {
+                    type: "array",
+                    items: { type: "string", enum: ["people", "events"] },
+                    description: "Low-level datasets to export. people is one deduped prospect row; events is one action row. Omit this and use exportIntent for clearer behavior.",
+                },
+                actionTypes: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                        enum: [
+                            "INVITE",
+                            "DM",
+                            "INMAIL_OPEN",
+                            "INMAIL_CLOSED",
+                            "VIEW_PROFILE",
+                            "COMMENT",
+                        ],
+                    },
+                    description: "Optional low-level action filter. Usually omit and use exportIntent. Dashboard messages are DM + INMAIL_OPEN + INMAIL_CLOSED; reached-out/contact events are INVITE + DM + INMAIL_OPEN + INMAIL_CLOSED.",
+                },
+                outputDir: {
+                    type: "string",
+                    description: "Optional base directory. A unique run subdirectory is created inside it.",
+                },
+                fromSentAt: {
+                    type: "string",
+                    description: "Optional ISO lower bound for outreach sentAt.",
+                },
+                toSentAt: {
+                    type: "string",
+                    description: "Optional ISO upper bound for outreach sentAt.",
+                },
+                campaignIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional campaign ids to include, max 100.",
+                },
+                tableIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional workflow table ids to include, max 100.",
+                },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+    },
+];
+const CONTACT_ACTION_TYPES = [
+    "INVITE",
+    "DM",
+    "INMAIL_OPEN",
+    "INMAIL_CLOSED",
+];
+const DASHBOARD_MESSAGE_ACTION_TYPES = [
+    "DM",
+    "INMAIL_OPEN",
+    "INMAIL_CLOSED",
+];
+const ALL_ACTION_TYPES = [
+    "INVITE",
+    "DM",
+    "INMAIL_OPEN",
+    "INMAIL_CLOSED",
+    "VIEW_PROFILE",
+    "COMMENT",
+];
+const EXPORT_INTENT_CONFIG = {
+    reached_out_people: {
+        datasets: ["people"],
+        actionTypes: CONTACT_ACTION_TYPES,
+        description: "Unique prospects who received at least one actual contact attempt: invite, DM, open InMail, or paid/closed InMail.",
+    },
+    people_and_events: {
+        datasets: ["people", "events"],
+        actionTypes: CONTACT_ACTION_TYPES,
+        description: "Reached-out people plus one matching contact event row per invite, DM, open InMail, or paid/closed InMail.",
+    },
+    outreach_event_log: {
+        datasets: ["events"],
+        actionTypes: ALL_ACTION_TYPES,
+        description: "Raw workflow-table-backed action event log for audit/reconciliation, including profile views and comments when present.",
+    },
+    dashboard_messages: {
+        datasets: ["events"],
+        actionTypes: DASHBOARD_MESSAGE_ACTION_TYPES,
+        description: "Message events only, matching the dashboard Messages Sent card: DMs + open InMails + paid/closed InMails.",
+    },
+    connections_sent: {
+        datasets: ["events"],
+        actionTypes: ["INVITE"],
+        description: "Connection invite events only, matching the dashboard Connections Sent sub-count.",
+    },
+};
+function assertIsoDate(value, field) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    if (typeof value !== "string")
+        throw new Error(`${field} must be a string`);
+    const date = new Date(value);
+    if (!Number.isFinite(date.getTime())) {
+        throw new Error(`${field} must be a valid ISO date`);
+    }
+    return date.toISOString();
+}
+function assertIdList(value, field) {
+    if (value === undefined || value === null)
+        return [];
+    if (!Array.isArray(value))
+        throw new Error(`${field} must be an array`);
+    if (value.length > MAX_FILTER_IDS) {
+        throw new Error(`${field} supports at most ${MAX_FILTER_IDS} ids`);
+    }
+    return value.map((id) => {
+        if (typeof id !== "string" || !/^[A-Za-z0-9_.:-]+$/.test(id)) {
+            throw new Error(`${field} contains an invalid id`);
+        }
+        return id;
+    });
+}
+function normalizeDatasets(value) {
+    if (value === undefined || value === null)
+        return ["people", "events"];
+    if (!Array.isArray(value))
+        throw new Error("datasets must be an array");
+    if (value.length === 0)
+        throw new Error("datasets cannot be empty");
+    const unique = Array.from(new Set(value));
+    return unique.map((dataset) => {
+        if (dataset !== "people" && dataset !== "events") {
+            throw new Error("datasets may only contain people or events");
+        }
+        return dataset;
+    });
+}
+function normalizeExportIntent(value) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    if (value !== "reached_out_people" &&
+        value !== "people_and_events" &&
+        value !== "outreach_event_log" &&
+        value !== "dashboard_messages" &&
+        value !== "connections_sent") {
+        throw new Error("exportIntent is not supported");
+    }
+    return value;
+}
+function normalizeActionTypes(value) {
+    if (value === undefined || value === null)
+        return [];
+    if (!Array.isArray(value))
+        throw new Error("actionTypes must be an array");
+    if (value.length === 0)
+        throw new Error("actionTypes cannot be empty");
+    const unique = Array.from(new Set(value));
+    return unique.map((actionType) => {
+        if (actionType !== "INVITE" &&
+            actionType !== "DM" &&
+            actionType !== "INMAIL_OPEN" &&
+            actionType !== "INMAIL_CLOSED" &&
+            actionType !== "VIEW_PROFILE" &&
+            actionType !== "COMMENT") {
+            throw new Error("actionTypes contains an unsupported action type");
+        }
+        return actionType;
+    });
+}
+function validateInput(input) {
+    if (input.exportType && input.exportType !== "outreach") {
+        throw new Error("exportType must be outreach");
+    }
+    const exportIntent = normalizeExportIntent(input.exportIntent);
+    const intentConfig = exportIntent ? EXPORT_INTENT_CONFIG[exportIntent] : null;
+    const fromSentAt = assertIsoDate(input.fromSentAt, "fromSentAt");
+    const toSentAt = assertIsoDate(input.toSentAt, "toSentAt");
+    if (fromSentAt && toSentAt && new Date(fromSentAt) > new Date(toSentAt)) {
+        throw new Error("fromSentAt must be before toSentAt");
+    }
+    const actionTypes = normalizeActionTypes(input.actionTypes);
+    return {
+        exportIntent,
+        intentDescription: intentConfig?.description ?? null,
+        datasets: input.datasets === undefined || input.datasets === null
+            ? (intentConfig?.datasets ?? ["people", "events"])
+            : normalizeDatasets(input.datasets),
+        actionTypes: actionTypes.length > 0 ? actionTypes : (intentConfig?.actionTypes ?? []),
+        outputDir: input.outputDir,
+        fromSentAt,
+        toSentAt,
+        campaignIds: assertIdList(input.campaignIds, "campaignIds"),
+        tableIds: assertIdList(input.tableIds, "tableIds"),
+    };
+}
+function countDefinitions() {
+    return {
+        reachedOutPeople: "Deduped prospects with at least one actual contact attempt: INVITE, DM, INMAIL_OPEN, or INMAIL_CLOSED. This is what 'everyone we reached out to' should mean.",
+        outreachEvents: "One row per exported LinkedInOutreach action event after workspace, date, campaign/table, and action-type filters.",
+        dashboardMessagesSent: "Dashboard Messages Sent equals DM + INMAIL_OPEN + INMAIL_CLOSED events. It excludes connection invites.",
+        connectionsSent: "Dashboard Connections Sent equals INVITE events. Accepted invites show separately as Connections Made.",
+        profileViews: "VIEW_PROFILE is an action event for audit logs, but it is not a contact attempt and should not define reached-out people.",
+    };
+}
+async function packageVersion() {
+    const entryDir = process.argv[1]
+        ? path.dirname(path.resolve(process.argv[1]))
+        : process.cwd();
+    const candidates = [
+        path.resolve(process.cwd(), "mcp/sellable/package.json"),
+        path.resolve(entryDir, "../package.json"),
+        path.resolve(entryDir, "../../package.json"),
+    ];
+    for (const candidate of candidates) {
+        try {
+            const raw = await readFile(candidate, "utf8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.version === "string")
+                return parsed.version;
+        }
+        catch {
+            // Try the next runtime/package layout.
+        }
+    }
+    return null;
+}
+async function ensureSafeBaseDir(outputDir) {
+    const baseDir = path.resolve(outputDir || path.join(tmpdir(), "sellable-mcp-exports"));
+    await mkdir(baseDir, { recursive: true });
+    const baseStat = await lstat(baseDir);
+    if (baseStat.isSymbolicLink()) {
+        throw new Error("outputDir must not be a symlink");
+    }
+    if (!baseStat.isDirectory()) {
+        throw new Error("outputDir must be a directory");
+    }
+    return baseDir;
+}
+async function createRunDir(outputDir) {
+    const baseDir = await ensureSafeBaseDir(outputDir);
+    for (let attempt = 0; attempt < 10; attempt++) {
+        const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const runDir = path.join(baseDir, `workspace-outreach-${stamp}-${process.pid}-${attempt}`);
+        try {
+            await mkdir(runDir, { recursive: false });
+            return runDir;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+    }
+    throw new Error("Failed to create unique export directory");
+}
+function buildQuery(params) {
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (Array.isArray(value)) {
+            if (value.length > 0)
+                searchParams.set(key, value.join(","));
+        }
+        else if (value) {
+            searchParams.set(key, value);
+        }
+    }
+    const query = searchParams.toString();
+    if (query.length > MAX_QUERY_LENGTH) {
+        throw new Error("Export query string is too long");
+    }
+    return query ? `?${query}` : "";
+}
+async function countCsvRows(filePath) {
+    const parser = createReadStream(filePath).pipe(parse({ bom: true, relax_column_count: true }));
+    let records = 0;
+    for await (const _record of parser) {
+        records += 1;
+    }
+    return Math.max(0, records - 1);
+}
+function redactManifest(value) {
+    if (Array.isArray(value))
+        return value.map(redactManifest);
+    if (!value || typeof value !== "object")
+        return value;
+    const entries = Object.entries(value).map(([key, entry]) => {
+        if (/token|secret|authorization|api[_-]?key/i.test(key)) {
+            return [key, "[redacted]"];
+        }
+        return [key, redactManifest(entry)];
+    });
+    return Object.fromEntries(entries);
+}
+async function writeJsonAtomic(filePath, value) {
+    const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    await writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, {
+        encoding: "utf8",
+        flag: "wx",
+    });
+    await rename(tempPath, filePath);
+}
+export async function exportWorkspaceCsv(input = {}) {
+    const config = getConfig();
+    const workspaceId = config.activeWorkspaceId || config.workspaceId || null;
+    if (!workspaceId) {
+        throw new Error("No active workspace selected. Run list_workspaces then set_active_workspace before export_workspace_csv.");
+    }
+    const validated = validateInput(input);
+    const startedAt = new Date().toISOString();
+    const runDir = await createRunDir(validated.outputDir);
+    const api = getApi();
+    const metadataQuery = buildQuery({
+        fromSentAt: validated.fromSentAt,
+        toSentAt: validated.toSentAt,
+        campaignIds: validated.campaignIds,
+        tableIds: validated.tableIds,
+        actionTypes: validated.actionTypes,
+    });
+    const metadataEndpoint = `/api/v3/mcp/workspace-export/outreach/metadata${metadataQuery}`;
+    const backendMetadata = await api.get(metadataEndpoint);
+    const exportCutoff = backendMetadata.exportCutoff;
+    if (!exportCutoff) {
+        throw new Error("Export metadata did not include exportCutoff");
+    }
+    const files = [];
+    const failures = [];
+    for (const dataset of validated.datasets) {
+        const query = buildQuery({
+            dataset,
+            exportCutoff,
+            fromSentAt: validated.fromSentAt,
+            toSentAt: validated.toSentAt,
+            campaignIds: validated.campaignIds,
+            tableIds: validated.tableIds,
+            actionTypes: validated.actionTypes,
+        });
+        const endpoint = `/api/v3/mcp/workspace-export/outreach${query}`;
+        const filePath = path.join(runDir, `outreach-${dataset}.csv`);
+        try {
+            const download = await api.downloadToFile(endpoint, filePath);
+            files.push({
+                dataset,
+                path: download.path,
+                rows: await countCsvRows(download.path),
+                bytes: download.bytes,
+                endpoint,
+                contentType: download.contentType,
+                status: "complete",
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            failures.push({ dataset, error: message });
+            files.push({
+                dataset,
+                path: filePath,
+                rows: 0,
+                bytes: 0,
+                endpoint,
+                contentType: null,
+                status: "failed",
+                error: message,
+            });
+            await rm(filePath, { force: true }).catch(() => undefined);
+        }
+    }
+    const manifest = redactManifest({
+        status: failures.length > 0 ? "partial" : "success",
+        tool: "export_workspace_csv",
+        exportType: "outreach",
+        exportIntent: validated.exportIntent ?? "legacy_datasets",
+        intentDescription: validated.intentDescription,
+        countDefinitions: countDefinitions(),
+        startedAt,
+        completedAt: new Date().toISOString(),
+        package: {
+            name: "@sellable/mcp",
+            version: await packageVersion(),
+        },
+        config: {
+            apiUrl: config.apiUrl,
+            activeWorkspaceId: workspaceId,
+            activeWorkspaceName: config.activeWorkspaceName || config.workspaceName,
+        },
+        backend: {
+            metadataEndpoint,
+            metadata: backendMetadata,
+        },
+        filters: {
+            fromSentAt: validated.fromSentAt ?? null,
+            toSentAt: validated.toSentAt ?? null,
+            campaignIds: validated.campaignIds,
+            tableIds: validated.tableIds,
+            actionTypes: validated.actionTypes,
+            exportCutoff,
+        },
+        outputDir: runDir,
+        files,
+        failures,
+    });
+    const manifestPath = path.join(runDir, "manifest.json");
+    await writeJsonAtomic(manifestPath, manifest);
+    return {
+        status: failures.length > 0 ? "partial" : "success",
+        outputDir: runDir,
+        manifestPath,
+        datasets: files.map((file) => ({
+            dataset: file.dataset,
+            path: file.path,
+            rows: file.rows,
+            bytes: file.bytes,
+            status: file.status,
+        })),
+        exportCutoff,
+        exportIntent: validated.exportIntent ?? null,
+        intentDescription: validated.intentDescription,
+        countDefinitions: countDefinitions(),
+        counts: backendMetadata.counts ?? {},
+        workspace: backendMetadata.workspace ?? {
+            id: workspaceId,
+            name: config.activeWorkspaceName || config.workspaceName || null,
+        },
+        skipped: backendMetadata.skipped ?? [],
+        failures,
+    };
+}

package/package.json

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

package/skills/create-evergreen-campaigns/SKILL.md

@@ -155,15 +155,19 @@ execution boundary, not guidance. Read and preserve `workerDispatch.acceptedRunt
 before dispatch.
 
 Worker fan-out must use visible or durable execution. Preferred in local Codex
-is a visible Codex thread created with `codex_app.create_thread`; the parent
-must record the returned thread id, pass exactly one lane packet into that
-thread, and require the worker to write the lane receipt at the artifact path
-named by `workerDispatch.receiptArtifactHint`. A streaming worker or branch
-worker is acceptable only when it writes a durable per-lane receipt artifact as
-it works. `multi_agent_v1.spawn_agent`, raw `spawn_agent`, or any opaque
-Task/subagent runtime that cannot expose a visible thread id or durable receipt
-artifact is not accepted as command-level UAT proof and must not be used for
-mutating evergreen setup.
+is a visible Codex thread created with the actual Codex app thread tools:
+first call `codex_app.list_projects`, select the current repo project, then
+call `codex_app.create_thread` with `target:{type:"project", projectId,
+environment:{type:"local"}}`. Do not create a worktree target for evergreen
+UAT or lane execution. The parent must record the returned thread id, pass
+exactly one lane packet into that thread, and require the worker to write the
+lane receipt at the artifact path named by
+`workerDispatch.receiptArtifactHint`. A streaming worker or branch worker is
+acceptable only when it writes a durable per-lane receipt artifact as it works.
+`multi_agent_v1.spawn_agent`, raw `spawn_agent`, or any opaque Task/subagent
+runtime that cannot expose a visible thread id or durable receipt artifact is
+not accepted as command-level UAT proof and must not be used for mutating
+evergreen setup.
 
 Run this preflight before the first irreversible product mutation in any lane:
 the parent must have recorded either a visible Codex thread id or a durable
@@ -293,6 +297,8 @@ The receipt status must be `status:"succeeded"` or `status:"completed"` when
 the lane is complete. Do not use `status:"passed"` or
 `status:"passed_with_warnings"` as the primary success status. Warnings may go
 in a separate `warnings` array, but the completion status stays canonical.
+The backend verifier rejects `status:"passed"`, `status:"pass"`, and
+`status:"passed_with_warnings"` as primary completion statuses.
 
 All step proof objects must live under `createCampaignStepReceipt`. Do not put
 `createCampaignWorkflowReceipt`, `campaignBriefReceipt`,
@@ -451,6 +457,9 @@ includes the same prompt/assets/validation proof, current campaign/table/source
 basis, generated review rows, sample messages, quality review, route-proof
 approval evidence, sequence proof, and final paused-send proof required of the
 branch handoff. `statusSource:"parent-thread-fallback"` is still invalid.
+The only accepted statusSource values are exactly `branch` and
+`packaged-generate-messages-worker`; descriptive aliases such as
+`package-readback-local-thread` are rejected.
 
 One lane may produce exactly one CampaignOffer/campaign id and one current
 workflow table id. For `intent:"create"`, the first successful