@sellable/mcp 0.1.368 → 0.1.370

package/skills/refill-sends-workflow/SKILL.md

@@ -7,6 +7,9 @@ allowed-tools:
   - mcp__sellable__get_campaign_refill_state
   - mcp__sellable__fill_campaign_horizon
   - mcp__sellable__get_campaign
+  - mcp__sellable__get_campaign_context
+  - mcp__sellable__update_campaign
+  - mcp__sellable__get_provider_prompt
   - mcp__sellable__get_campaign_message_preparation_status
   - mcp__sellable__start_campaign_message_preparation
   - mcp__sellable__cancel_campaign_message_preparation
@@ -14,6 +17,7 @@ allowed-tools:
   - mcp__sellable__wait_for_lead_list_ready
   - mcp__sellable__confirm_lead_list
   - mcp__sellable__search_signals
+  - mcp__sellable__select_promising_posts
   - mcp__sellable__fetch_post_engagers
   - mcp__sellable__search_sales_nav
   - mcp__sellable__lookup_sales_nav_filter
@@ -27,6 +31,10 @@ allowed-tools:
   - mcp__sellable__get_rows
   - mcp__sellable__get_rows_minimal
   - mcp__sellable__get_table_rows
+  - mcp__sellable__get_campaign_table_schema
+  - mcp__sellable__select_campaign_cells
+  - mcp__sellable__wait_for_campaign_processing
+  - mcp__sellable__get_sender
 ---
 
 # Refill Sends Workflow
@@ -101,6 +109,42 @@ Source replenishment choices:
   source prospects into the same campaign/source-list path, then confirm
   readiness.
 
+### Running Campaign Signal Discovery Recovery
+
+For an already-running regular campaign that needs same-campaign Signal
+Discovery replenishment, treat the watch/current-step transition as a guarded
+repair, not as normal create-campaign navigation.
+
+Do not call `search_signals` with `currentStep:"signal-discovery"` directly from `currentStep:"running"`. The campaign step guard intentionally rejects that
+backwards transition. After exact approval and a fresh refill-state reread, clear `currentStep` only if it still exactly matches `running`:
+
+```text
+update_campaign({ campaignId, currentStep:null, clearCurrentStepIfMatches:"running" })
+```
+
+Then register provider preflight and run a campaign-scoped `search_signals` so
+post rows exist in the campaign's Signal Discovery state:
+
+```text
+get_provider_prompt({ provider:"signal-discovery", campaignOfferId, confirmed:true })
+search_signals({ campaignOfferId, currentStep:"signal-discovery", confirmed:true, ... })
+```
+
+Use `select_promising_posts` before importing. For a fresh source refill, prefer
+`selectionMode:"replace"` and `scrapePlanMode:"capacity-target"` with the
+approved `targetEngagerCount` and `maxPostsToScrape`. If the approved post set cannot cover the target, do not knowingly run an under-capacity scrape; ask for approval to expand the selected post set or switch source.
+
+If `import_leads` returns `reusedExistingSourceList` but the user explicitly
+approved a different selected-post scrape, retry `import_leads` with the existing `sourceLeadListId` from that response or from refill state. For Signal
+Discovery this bypasses the stale reuse guard and materializes the newly
+selected campaign-scoped posts into a fresh source list.
+
+After `wait_for_lead_list_ready`, call `confirm_lead_list` with the new
+source-list id and same campaign id. Pass `currentStep:"running"` to `confirm_lead_list` for an ACTIVE already-running campaign so the watched state
+returns to Running after same-campaign source rows are copied. Do not call
+`update_campaign` to fake this after the copy; `confirm_lead_list` owns the
+post-copy state transition.
+
 Before any source mutation, show exact approval evidence: workspace id,
 campaign id, workflow table id, source/provider id, source-list id when known,
 import caps, target dates/caps, dedupe/DNC/provider exclusion expectations, and
@@ -135,11 +179,28 @@ Before prep or approval mutation, reread `get_campaign_refill_state` and compare
 If they changed, stop. A second concurrent refill run must see the first run's
 import/prep state on reread and avoid duplicate work.
 
+After same-campaign source copy, inspect the actual campaign-table position of
+the copied rows before starting prep. Newly copied rows often land after the first 100 table rows. Use `get_campaign_table_schema` to read the `reviewBatch`,
+then use `select_campaign_cells` diagnostics against
+`rowSelector:{ type:"reviewBatch" }` for `enrich`, `generateMessage`, and
+`approved` roles when needed.
+
+If review-batch enrich cells are pending or Generate Message cells are
+dependency-blocked, omit `maxRowsToCheck` so the adaptive prep job can cover the
+bounded table scan, or set a bounded cap high enough to include appended rows
+when row count evidence requires it. Do not run a fixed `maxRowsToCheck:100` prep pass after appending rows to a larger existing campaign table; it can spend
+the whole budget on older rows and miss the refill batch.
+
 Scheduled success requires a post-action reread proving scheduler-owned cells
 with non-null `scheduledFor`. Prepared, approved, and ready-to-schedule rows are
 intermediate states; report them as awaiting scheduler unless scheduled cells
 are present.
 
+preparedMessages can remain 0 while scheduler-ready state changes downstream.
+After a prep job reaches a terminal state, run `wait_for_campaign_processing`
+when generated/pass counts are still settling, then poll `get_campaign_refill_state` until `readyToSchedule` drops, scheduled counts increase, or the state clearly
+remains awaiting scheduler. Do not force scheduler fields directly.
+
 ## Evergreen Campaign Discipline
 
 `fill_campaign_horizon` is a legacy evergreen-only lower-level primitive. Call it

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

@@ -1,110 +0,0 @@
-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

@@ -1,465 +0,0 @@
-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,
-    };
-}