@sellable/mcp 0.1.504 → 0.1.505

package/dist/tools/scheduler-fill-capacity.js

@@ -1,7 +1,11 @@
 import { getApi } from "../api.js";
-async function postSchedulerFillCapacity(body) {
+import { normalizeExplicitWorkspaceId, workspaceRequestOptions, } from "./workspace-context.js";
+async function postSchedulerFillCapacity(body, workspaceId) {
     const api = getApi();
-    return api.post("/api/v3/mcp/scheduler-fill-capacity", body);
+    const requestOptions = workspaceRequestOptions(workspaceId);
+    return requestOptions
+        ? api.post("/api/v3/mcp/scheduler-fill-capacity", body, requestOptions)
+        : api.post("/api/v3/mcp/scheduler-fill-capacity", body);
 }
 export const schedulerFillCapacityToolDefinitions = [
     {
@@ -55,6 +59,10 @@ export const schedulerFillCapacityToolDefinitions = [
                     enum: ["default_horizon", "target_date"],
                     description: "Optional mode hint. Omit for default_horizon; target_date requires targetDate.",
                 },
+                workspaceId: {
+                    type: "string",
+                    description: "Explicit request-scoped workspace id for scheduled/yolo refill automation. Pass this instead of switching the shared active workspace.",
+                },
             },
             required: ["capacityRequests"],
             additionalProperties: false,
@@ -62,9 +70,11 @@ export const schedulerFillCapacityToolDefinitions = [
     },
 ];
 export function getSchedulerFillCapacity(input) {
+    const workspaceId = normalizeExplicitWorkspaceId(input.workspaceId);
     return postSchedulerFillCapacity({
         capacityRequests: input.capacityRequests,
         targetDate: input.targetDate,
         mode: input.mode,
-    });
+        ...(workspaceId ? { workspaceId } : {}),
+    }, workspaceId ?? undefined);
 }

package/dist/tools/sender-routing.d.ts

@@ -14,6 +14,10 @@ export declare const senderRoutingToolDefinitions: ({
     inputSchema: {
         type: string;
         properties: {
+            workspaceId: {
+                type: string;
+                description: string;
+            };
             rulesMarkdown?: undefined;
         };
         required: never[];
@@ -29,12 +33,15 @@ export declare const senderRoutingToolDefinitions: ({
                 type: string;
                 description: string;
             };
+            workspaceId?: undefined;
         };
         required: never[];
         additionalProperties: boolean;
     };
 })[];
-export declare function getSenderRoutingTool(): Promise<SenderRoutingResponse>;
+export declare function getSenderRoutingTool(input?: {
+    workspaceId?: string;
+}): Promise<SenderRoutingResponse>;
 export declare function setSenderRoutingTool(input?: {
     rulesMarkdown?: string;
 }): Promise<{

package/dist/tools/sender-routing.js

@@ -1,4 +1,5 @@
 import { getApi } from "../api.js";
+import { workspaceRequestOptions } from "./workspace-context.js";
 const MAX_RULES_MARKDOWN_LENGTH = 65536;
 export const senderRoutingToolDefinitions = [
     {
@@ -6,7 +7,12 @@ export const senderRoutingToolDefinitions = [
         description: "Return the workspace's territory routing rules markdown plus the connected sender roster. If configured is false, routing is inactive and all campaign senders are eligible everywhere.",
         inputSchema: {
             type: "object",
-            properties: {},
+            properties: {
+                workspaceId: {
+                    type: "string",
+                    description: "Explicit request-scoped workspace id for scheduled/yolo refill automation. Pass this instead of switching the shared active workspace.",
+                },
+            },
             required: [],
             additionalProperties: false,
         },
@@ -27,9 +33,12 @@ export const senderRoutingToolDefinitions = [
         },
     },
 ];
-export async function getSenderRoutingTool() {
+export async function getSenderRoutingTool(input = {}) {
     const api = getApi();
-    return api.get("/api/v3/sender-routing");
+    const requestOptions = workspaceRequestOptions(input.workspaceId);
+    return requestOptions
+        ? api.get("/api/v3/sender-routing", requestOptions)
+        : api.get("/api/v3/sender-routing");
 }
 export async function setSenderRoutingTool(input = {}) {
     if (input.rulesMarkdown &&

package/dist/tools/senders.d.ts

@@ -22,14 +22,19 @@ export type SenderListItem = {
 export type ListSendersResponse = {
     senders: SenderListItem[];
 };
+export type ListSendersInput = {
+    workspaceId?: string;
+};
 export type GetSenderInput = {
     senderId: string;
+    workspaceId?: string;
 };
 export type SenderDetailResponse = {
     sender: any;
 };
 export type RefreshPaidInmailCreditsInput = {
     senderId: string;
+    workspaceId?: string;
 };
 export type PaidInmailCreditStatus = {
     available: number;
@@ -57,6 +62,10 @@ export declare const senderToolDefinitions: ({
     inputSchema: {
         type: string;
         properties: {
+            workspaceId: {
+                type: string;
+                description: string;
+            };
             senderId?: undefined;
         };
         required: never[];
@@ -72,12 +81,16 @@ export declare const senderToolDefinitions: ({
                 type: string;
                 description: string;
             };
+            workspaceId: {
+                type: string;
+                description: string;
+            };
         };
         required: string[];
         additionalProperties: boolean;
     };
 })[];
-export declare function listSenders(): Promise<ListSendersResponse>;
+export declare function listSenders(input?: ListSendersInput): Promise<ListSendersResponse>;
 export declare function getSender(input: GetSenderInput): Promise<SenderDetailResponse>;
 export declare function refreshPaidInmailCredits(input: RefreshPaidInmailCreditsInput): Promise<RefreshPaidInmailCreditsResponse>;
 export {};

package/dist/tools/senders.js

@@ -1,5 +1,6 @@
 import { getApi } from "../api.js";
 import { isLinkedInProfileInput, normalizeLinkedInProfileInput, } from "./linkedin-url.js";
+import { normalizeExplicitWorkspaceId, workspaceRequestOptions, } from "./workspace-context.js";
 function pickString(...values) {
     for (const value of values) {
         if (typeof value !== "string")
@@ -107,7 +108,12 @@ export const senderToolDefinitions = [
         description: "List outbound sender identities available in the active workspace, including LinkedIn profile URL and verified identity proof when available. In create-campaign flows, use this at Settings/final launch handoff to verify available connected senders; auto-select only when a sender has an exact identity match to the researched campaign identity. If identity proof is missing, ask the user to confirm the sender.",
         inputSchema: {
             type: "object",
-            properties: {},
+            properties: {
+                workspaceId: {
+                    type: "string",
+                    description: "Explicit request-scoped workspace id for scheduled/yolo refill automation. Pass this instead of switching the shared active workspace.",
+                },
+            },
             required: [],
             additionalProperties: false,
         },
@@ -119,6 +125,10 @@ export const senderToolDefinitions = [
             type: "object",
             properties: {
                 senderId: { type: "string", description: "Outbound sender ID" },
+                workspaceId: {
+                    type: "string",
+                    description: "Explicit request-scoped workspace id for scheduled/yolo refill automation.",
+                },
             },
             required: ["senderId"],
             additionalProperties: false,
@@ -134,15 +144,22 @@ export const senderToolDefinitions = [
                     type: "string",
                     description: "Exact Sender.id to refresh. The API verifies the sender belongs to the active workspace.",
                 },
+                workspaceId: {
+                    type: "string",
+                    description: "Explicit request-scoped workspace id for scheduled/yolo refill automation. Pass this instead of switching the shared active workspace.",
+                },
             },
             required: ["senderId"],
             additionalProperties: false,
         },
     },
 ];
-export async function listSenders() {
+export async function listSenders(input = {}) {
     const api = getApi();
-    const senders = await api.get("/api/v1/outbound-sender-identities");
+    const requestOptions = workspaceRequestOptions(input.workspaceId);
+    const senders = requestOptions
+        ? await api.get("/api/v1/outbound-sender-identities", requestOptions)
+        : await api.get("/api/v1/outbound-sender-identities");
     return {
         senders: (senders || []).map((s) => {
             const linkedinProfileUrl = computeLinkedinProfileUrl(s);
@@ -163,7 +180,11 @@ export async function listSenders() {
 }
 export async function getSender(input) {
     const api = getApi();
-    const sender = await api.get(`/api/v1/outbound-sender-identities/${encodeURIComponent(input.senderId)}`);
+    const requestOptions = workspaceRequestOptions(input.workspaceId);
+    const path = `/api/v1/outbound-sender-identities/${encodeURIComponent(input.senderId)}`;
+    const sender = requestOptions
+        ? await api.get(path, requestOptions)
+        : await api.get(path);
     return { sender };
 }
 function normalizeCreditStatus(raw) {
@@ -187,7 +208,12 @@ export async function refreshPaidInmailCredits(input) {
         throw new Error("senderId is required.");
     }
     const api = getApi();
-    const result = await api.post(`/api/v3/senders/${encodeURIComponent(senderId)}/refresh-inmail-credits`, {});
+    const workspaceId = normalizeExplicitWorkspaceId(input.workspaceId);
+    const requestOptions = workspaceRequestOptions(workspaceId);
+    const body = workspaceId ? { workspaceId } : {};
+    const result = requestOptions
+        ? await api.post(`/api/v3/senders/${encodeURIComponent(senderId)}/refresh-inmail-credits`, body, requestOptions)
+        : await api.post(`/api/v3/senders/${encodeURIComponent(senderId)}/refresh-inmail-credits`, body);
     return {
         senderId,
         refreshed: true,

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

@@ -0,0 +1,36 @@
+import type { ApiRequestOptions } from "../api.js";
+export type WorkspaceExecutionMode = "manual" | "scheduled" | "yolo";
+export interface CreateWorkspaceContextInput {
+    workspaceId?: string | null;
+    executionMode: WorkspaceExecutionMode;
+    toolName?: string;
+    runId?: string;
+}
+export interface WorkspaceContext {
+    workspaceId: string;
+    requestOptions: Readonly<ApiRequestOptions>;
+    executionMode: WorkspaceExecutionMode;
+    toolName?: string;
+    runId: string;
+    workspaceResolution: "explicit";
+}
+export interface WorkspaceRequiredResult {
+    ok: false;
+    code: "WORKSPACE_REQUIRED";
+    message: string;
+    executionMode: WorkspaceExecutionMode;
+    toolName?: string;
+    workspaceResolution: "missing";
+}
+export interface WorkspaceContextResult {
+    ok: true;
+    context: Readonly<WorkspaceContext>;
+}
+export type CreateWorkspaceContextResult = WorkspaceContextResult | WorkspaceRequiredResult;
+export declare function workspaceRequired(params: {
+    executionMode: WorkspaceExecutionMode;
+    toolName?: string;
+}): WorkspaceRequiredResult;
+export declare function normalizeExplicitWorkspaceId(value: unknown): string | null;
+export declare function workspaceRequestOptions(workspaceId: unknown): Readonly<ApiRequestOptions> | undefined;
+export declare function createWorkspaceContext(input: CreateWorkspaceContextInput): CreateWorkspaceContextResult;

package/dist/tools/workspace-context.js

@@ -0,0 +1,39 @@
+import { randomUUID } from "node:crypto";
+export function workspaceRequired(params) {
+    const toolLabel = params.toolName ? ` for ${params.toolName}` : "";
+    return {
+        ok: false,
+        code: "WORKSPACE_REQUIRED",
+        message: `Explicit workspaceId is required${toolLabel} in ${params.executionMode} mode. ` +
+            "Pass workspaceId on the tool call instead of switching the shared active workspace.",
+        executionMode: params.executionMode,
+        toolName: params.toolName,
+        workspaceResolution: "missing",
+    };
+}
+export function normalizeExplicitWorkspaceId(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+export function workspaceRequestOptions(workspaceId) {
+    const normalized = normalizeExplicitWorkspaceId(workspaceId);
+    return normalized ? Object.freeze({ workspaceId: normalized }) : undefined;
+}
+export function createWorkspaceContext(input) {
+    const workspaceId = normalizeExplicitWorkspaceId(input.workspaceId);
+    if (!workspaceId) {
+        return workspaceRequired({
+            executionMode: input.executionMode,
+            toolName: input.toolName,
+        });
+    }
+    const requestOptions = Object.freeze({ workspaceId });
+    const context = Object.freeze({
+        workspaceId,
+        requestOptions,
+        executionMode: input.executionMode,
+        toolName: input.toolName,
+        runId: input.runId?.trim() || randomUUID(),
+        workspaceResolution: "explicit",
+    });
+    return { ok: true, context };
+}

package/package.json

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

package/skills/refill-sends/SKILL.md

@@ -68,6 +68,9 @@ Accepted invocation flags in the same user request:
 
 - `--yolo`: auto-accept the rendered bounded refill packet after the required
   fresh state reread.
+- `workspaceId: <id>`: required for scheduled automation and `--yolo`; pass it
+  through on every refill MCP tool call instead of relying on shared config
+  state.
 - `--sender <name-or-id>`: scope to a specific sender; repeat for multiple
   senders.
 - `--until <YYYY-MM-DD>`: fill through that sender-local date, inclusive,
@@ -86,7 +89,7 @@ Accepted invocation flags in the same user request:
 When the host can call typed MCP tools, start with:
 
 ```text
-refill_sends({ yolo?: boolean, senders?: string[], senderIds?: string[], senderNames?: string[], horizonSendDays?: number, untilDate?: "YYYY-MM-DD", targetDate?: "YYYY-MM-DD" })
+refill_sends({ yolo?: boolean, executionMode?: "manual" | "scheduled" | "yolo", requireWorkspace?: boolean, workspaceId?: string, senders?: string[], senderIds?: string[], senderNames?: string[], horizonSendDays?: number, untilDate?: "YYYY-MM-DD", targetDate?: "YYYY-MM-DD" })
 ```
 
 That command helper normalizes arguments and returns the execution contract. In
@@ -100,9 +103,40 @@ or write scheduler rows. Continue with the workflow below for route selection,
 state rereads, approval gating, source import, preparation, and bounded
 approval.
 
-First call `get_auth_status({})`. If auth or active workspace is not OK, follow
-the returned login/workspace guidance before route resolution. Do not run refill
-research against an implicit or guessed workspace.
+## Workspace Contract
+
+First resolve the target workspace id from the user's request, automation config,
+or install-time workspace mapping. Pass `workspaceId` on every scheduled or
+`--yolo` refill tool call, including setup/read calls such as
+`refill_sends`, `get_refill_target_plan`, `list_senders`,
+`get_sender_routing`, `resolve_campaign_fill_route`,
+`get_campaign_refill_state`, `get_scheduler_fill_capacity`, and any later
+refill mutation covered by the packet. Missing `workspaceId` in scheduled or
+`--yolo` mode is a blocker; stop with `WORKSPACE_REQUIRED` instead of running
+against an implicit or guessed workspace.
+
+Do not solve scheduled or `--yolo` workspace uncertainty by changing the shared
+active workspace. Manual interactive workspace switching remains a separate
+diagnostic/setup flow, outside automation.
+
+Examples:
+
+```text
+refill_sends({ yolo:true, executionMode:"yolo", requireWorkspace:true, workspaceId:"cmlq1v8ms0000jx04ang4hi7e" })
+get_refill_target_plan({ intent:"plain", approvalMode:"approve", workspaceId:"cmlq1v8ms0000jx04ang4hi7e" })
+list_senders({ workspaceId:"cmlq1v8ms0000jx04ang4hi7e" })
+```
+
+Clover scheduled automation must name the Clover workspace explicitly:
+
+```text
+refill_sends({ yolo:false, executionMode:"scheduled", requireWorkspace:true, workspaceId:"cmlq1v8ms0000jx04ang4hi7e" })
+get_refill_target_plan({ intent:"plain", approvalMode:"mark_ready", workspaceId:"cmlq1v8ms0000jx04ang4hi7e" })
+```
+
+First call `get_auth_status({})`. If auth is not OK, follow the returned login
+guidance before route resolution. Do not run refill research against an implicit
+or guessed workspace.
 
 Treat "refill senders", "fill senders", "load everyone up", and "max out
 senders" as sender-scoped requests. The target set is senders enrolled in active
@@ -165,7 +199,8 @@ Structured planner packet:
   `Still need`.
 - `target.globalActionQueue` is the only cross-sender yolo execution queue.
   Execute exactly one globally ranked primitive from
-  `target.globalActionQueue[0]`, then rerun `get_refill_target_plan` before
+  `target.globalActionQueue[0]`, then rerun `get_refill_target_plan` with the
+  same `workspaceId` before
   choosing another action.
 - `manualAlternates` are not yolo actions. Threshold lowering and campaign
   creation are manual continuations only.
@@ -250,7 +285,7 @@ If Christian includes `--yolo` in the same refill request, treat that flag as
 auto-accept for the rendered bounded refill packet after the required fresh state
 reread. For sender-scoped language with no named senders, `--yolo` means all
 eligible healthy senders enrolled in active campaign-backed sequence campaigns in
-the active workspace. Without `--yolo`, if Christian did not name senders, ask
+the requested `workspaceId`. Without `--yolo`, if Christian did not name senders, ask
 which eligible enrolled senders to refill before choosing campaigns or mutating.
 
 `--yolo` only covers the exact sender set, per-sender target campaigns, caps,

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

@@ -61,6 +61,17 @@ senders", and "load everyone up". A sender-scoped request targets senders
 enrolled in active campaign-backed sequence campaigns, not one arbitrary active
 campaign.
 
+Workspace contract: scheduled automation and `--yolo` must carry an explicit
+request-scoped `workspaceId`. Pass that same `workspaceId` on every refill tool
+call in this workflow: `get_refill_target_plan`, `list_senders`,
+`get_sender_routing`, `resolve_campaign_fill_route`,
+`get_campaign_refill_state`, `get_scheduler_fill_capacity`,
+`refresh_paid_inmail_credits`, source import/readiness calls, preparation calls,
+approval calls, and campaign start calls. Missing `workspaceId` in scheduled or
+`--yolo` mode is a blocker; return or report `WORKSPACE_REQUIRED` instead of
+falling back to shared config state. Manual interactive workspace switching is
+diagnostic setup only and is not an automation control path.
+
 Goal-mode continuation: a skill cannot create or invoke `/goal` by itself. When
 this workflow is already running inside an active Codex goal, keep that goal
 open until every selected sender lane is horizon-filled by projected coverage
@@ -103,7 +114,8 @@ in-progress wait state, not a reason to mark the goal complete or blocked.
      `Still need`.
    - `target.globalActionQueue` is the only cross-sender yolo execution queue.
      execute exactly one globally ranked primitive from
-     `target.globalActionQueue[0]`, then rerun `get_refill_target_plan` before
+     `target.globalActionQueue[0]`, then rerun `get_refill_target_plan` with
+     the same `workspaceId` before
      choosing another action.
    - `nextActions[0]` is the current sender's smallest safe primitive.
    - `manualAlternates` are not yolo actions. Threshold lowering and campaign