@sellable/mcp 0.1.548 → 0.1.550

package/dist/tools/sequencer.d.ts

@@ -19,8 +19,7 @@ export type CreateWorkflowTableResponse = {
 };
 export type AttachSequenceInput = {
     tableId: string;
-    template?: Record<string, unknown>;
-    templateRef?: "connection_only";
+    template: Record<string, unknown>;
     confirmed?: boolean;
 };
 export type AttachSequenceResponse = {
@@ -75,7 +74,6 @@ export declare const sequencerToolDefinitions: ({
             };
             tableId?: undefined;
             template?: undefined;
-            templateRef?: undefined;
             confirmed?: undefined;
             campaignId?: undefined;
             currentStep?: undefined;
@@ -96,11 +94,6 @@ export declare const sequencerToolDefinitions: ({
                 type: string;
                 description: string;
             };
-            templateRef: {
-                type: string;
-                enum: string[];
-                description: string;
-            };
             confirmed: {
                 type: string;
                 description: string;
@@ -140,7 +133,6 @@ export declare const sequencerToolDefinitions: ({
             sequenceActions?: undefined;
             tableId?: undefined;
             template?: undefined;
-            templateRef?: undefined;
         };
         required: string[];
     };

package/dist/tools/sequencer.js

@@ -53,17 +53,12 @@ export const sequencerToolDefinitions = [
                     type: "object",
                     description: "Sequence template object with version, entryNodeId, nodes, and branches",
                 },
-                templateRef: {
-                    type: "string",
-                    enum: ["connection_only"],
-                    description: "Optional backend-owned known template reference. Use connection_only for invite-only evergreen setup without duplicating app template JSON in MCP.",
-                },
                 confirmed: {
                     type: "boolean",
                     description: "Set true to overwrite existing sequence columns if the table already has them",
                 },
             },
-            required: ["tableId"],
+            required: ["tableId", "template"],
         },
     },
     {
@@ -112,53 +107,55 @@ export async function attachSequence(input) {
     const api = getApi();
     const template = input.template;
     const preValidationErrors = [];
-    if (input.template && input.templateRef) {
-        throw new Error("INVALID_TEMPLATE: Pass either template or templateRef, not both.");
+    if (!Array.isArray(template.nodes) || template.nodes.length === 0) {
+        preValidationErrors.push("Template must have a non-empty 'nodes' array.");
     }
-    if (!input.template && !input.templateRef) {
-        throw new Error("INVALID_TEMPLATE: Pass template or templateRef.");
+    if (typeof template.entryNodeId !== "string" ||
+        template.entryNodeId.trim().length === 0) {
+        preValidationErrors.push("Template must have an 'entryNodeId' string.");
     }
-    if (input.template) {
-        if (!Array.isArray(template.nodes) || template.nodes.length === 0) {
-            preValidationErrors.push("Template must have a non-empty 'nodes' array.");
-        }
-        if (typeof template.entryNodeId !== "string" ||
-            template.entryNodeId.trim().length === 0) {
-            preValidationErrors.push("Template must have an 'entryNodeId' string.");
-        }
-        if (template.version !== 2) {
-            preValidationErrors.push("Template version must be 2.");
-        }
-        if (Array.isArray(template.nodes) &&
-            typeof template.entryNodeId === "string") {
-            const nodeIds = new Set(template.nodes
-                .map((node) => node && typeof node === "object"
-                ? node.id
-                : null)
-                .filter((nodeId) => typeof nodeId === "string"));
-            if (template.entryNodeId && !nodeIds.has(template.entryNodeId)) {
-                preValidationErrors.push(`entryNodeId "${template.entryNodeId}" does not match any node id. Available node ids: ${Array.from(nodeIds).join(", ")}`);
-            }
-        }
-        if (preValidationErrors.length > 0) {
-            throw new Error("INVALID_TEMPLATE: Template has structural issues:\n" +
-                preValidationErrors.map((issue) => `  - ${issue}`).join("\n") +
-                "\n\nFix these issues and retry.");
+    if (template.version !== 2) {
+        preValidationErrors.push("Template version must be 2.");
+    }
+    if (Array.isArray(template.nodes) &&
+        typeof template.entryNodeId === "string") {
+        const nodeIds = new Set(template.nodes
+            .map((node) => node && typeof node === "object"
+            ? node.id
+            : null)
+            .filter((nodeId) => typeof nodeId === "string"));
+        if (template.entryNodeId && !nodeIds.has(template.entryNodeId)) {
+            preValidationErrors.push(`entryNodeId "${template.entryNodeId}" does not match any node id. Available node ids: ${Array.from(nodeIds).join(", ")}`);
         }
     }
+    if (preValidationErrors.length > 0) {
+        throw new Error("INVALID_TEMPLATE: Template has structural issues:\n" +
+            preValidationErrors.map((issue) => `  - ${issue}`).join("\n") +
+            "\n\nFix these issues and retry.");
+    }
     // Campaign-backed tables route to the campaigns endpoint so the MCP
     // tool persists the sequence to the same place the UI does
     // (`CampaignOffer.sequenceTemplate`). The workflow-tables endpoint
     // writes to `WorkflowTable.config.sequenceTemplate`, which the UI
     // doesn't read — hitting it on a campaign table is silently wrong.
-    const campaignOfferId = await resolveCampaignOfferIdForTable(api, input.tableId);
+    let campaignOfferId = null;
+    try {
+        const tableMeta = await api.get(`/api/v3/workflow-tables/${input.tableId}?mode=meta`);
+        const rawCampaignId = tableMeta?.table?.config?.campaignOfferId;
+        if (typeof rawCampaignId === "string" && rawCampaignId.length > 0) {
+            campaignOfferId = rawCampaignId;
+        }
+    }
+    catch {
+        // Fall back to workflow-tables path on meta-fetch failure —
+        // non-campaign tables won't have the field set anyway.
+    }
     const endpoint = campaignOfferId
         ? `/api/v3/campaigns/${campaignOfferId}/sequence`
         : `/api/v3/workflow-tables/${input.tableId}/sequence`;
     try {
         return await api.put(endpoint, {
-            ...(input.template ? { template: input.template } : {}),
-            ...(input.templateRef ? { templateRef: input.templateRef } : {}),
+            template: input.template,
             confirmed: input.confirmed,
         });
     }
@@ -180,32 +177,6 @@ export async function attachSequence(input) {
         throw error;
     }
 }
-async function resolveCampaignOfferIdForTable(api, tableId) {
-    try {
-        const tableMeta = await api.get(`/api/v3/workflow-tables/${tableId}?mode=meta`);
-        const rawCampaignId = tableMeta?.table?.config?.campaignOfferId;
-        if (typeof rawCampaignId === "string" && rawCampaignId.length > 0) {
-            return rawCampaignId;
-        }
-    }
-    catch {
-        // Continue to the inventory fallback below.
-    }
-    try {
-        const tableInventory = await api.get("/api/v3/mcp/tables?limit=500");
-        const matchingTable = tableInventory?.tables?.find((table) => {
-            return table?.id === tableId;
-        });
-        const rawCampaignId = matchingTable?.campaignOfferId;
-        if (typeof rawCampaignId === "string" && rawCampaignId.length > 0) {
-            return rawCampaignId;
-        }
-    }
-    catch {
-        // Fall back to workflow-tables path on inventory failure.
-    }
-    return null;
-}
 export async function attachRecommendedSequence(input) {
     const api = getApi();
     try {

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

@@ -1,5 +1,4 @@
 type SetupEvergreenCampaignsInput = {
-    workspaceId?: string;
     mode?: "plan" | "verify";
     depth?: "structure_only" | "customer_visible";
     handoffMode?: "create_campaign_goals";
@@ -16,9 +15,6 @@ type SetupEvergreenCampaignsInput = {
     planRevision?: string;
     selectedActionIds?: string[];
     receipts?: Array<Record<string, unknown>>;
-    campaignSequenceOptions?: {
-        mode: "connection_only";
-    };
 };
 export declare const setupEvergreenCampaignsToolDefinitions: {
     name: string;
@@ -31,23 +27,6 @@ export declare const setupEvergreenCampaignsToolDefinitions: {
                 enum: string[];
                 description: string;
             };
-            workspaceId: {
-                type: string;
-                description: string;
-            };
-            campaignSequenceOptions: {
-                type: string;
-                properties: {
-                    mode: {
-                        type: string;
-                        enum: string[];
-                        description: string;
-                    };
-                };
-                required: string[];
-                additionalProperties: boolean;
-                description: string;
-            };
             depth: {
                 type: string;
                 enum: string[];

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

@@ -1,7 +1,7 @@
 import { getApi } from "../api.js";
-async function postSetupEvergreenCampaigns(body, workspaceId) {
+async function postSetupEvergreenCampaigns(body) {
     const api = getApi();
-    return api.post("/api/v3/mcp/setup-evergreen-campaigns", body, workspaceId ? { workspaceId } : undefined);
+    return api.post("/api/v3/mcp/setup-evergreen-campaigns", body);
 }
 export const setupEvergreenCampaignsToolDefinitions = [
     {
@@ -15,23 +15,6 @@ export const setupEvergreenCampaignsToolDefinitions = [
                     enum: ["plan", "verify"],
                     description: 'Defaults to "plan". Verify only validates worker receipts.',
                 },
-                workspaceId: {
-                    type: "string",
-                    description: "Optional explicit workspace id. Required for connection-only evergreen setup; it is also sent as the request workspace so concurrent threads cannot drift to another active workspace.",
-                },
-                campaignSequenceOptions: {
-                    type: "object",
-                    properties: {
-                        mode: {
-                            type: "string",
-                            enum: ["connection_only"],
-                            description: "Optional non-default sequence policy. connection_only means attach the canonical invite-only template and verify exactly send_invite, with no DM, InMail, View Profile, follow-up, launch, or send side effects.",
-                        },
-                    },
-                    required: ["mode"],
-                    additionalProperties: false,
-                    description: "Optional non-default evergreen sequence policy. Omit to keep the standard tier-recommended Premium/Sales Nav behavior.",
-                },
                 depth: {
                     type: "string",
                     enum: ["structure_only", "customer_visible"],
@@ -107,12 +90,10 @@ export const setupEvergreenCampaignsToolDefinitions = [
 ];
 export function setupEvergreenCampaigns(input) {
     return postSetupEvergreenCampaigns({
-        workspaceId: input.workspaceId,
         mode: input.mode,
         yolo: input.mode === "verify" ? undefined : input.yolo,
         depth: input.depth,
         handoffMode: input.mode === "verify" ? undefined : input.handoffMode,
-        campaignSequenceOptions: input.campaignSequenceOptions,
         allConnectedSenders: input.allConnectedSenders,
         selectedSenderIds: input.selectedSenderIds,
         postEngagerSenderIds: input.postEngagerSenderIds,
@@ -121,5 +102,5 @@ export function setupEvergreenCampaigns(input) {
         planRevision: input.planRevision,
         selectedActionIds: input.selectedActionIds,
         receipts: input.receipts,
-    }, input.workspaceId);
+    });
 }

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

@@ -12,7 +12,7 @@ export interface WorkspaceContext {
     executionMode: WorkspaceExecutionMode;
     toolName?: string;
     runId: string;
-    workspaceResolution: "explicit";
+    workspaceResolution: "explicit" | "locked_profile";
 }
 export interface WorkspaceRequiredResult {
     ok: false;

package/dist/tools/workspace-context.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { getLockedWorkspaceId, resolveWorkspaceIdForRequest, } from "../auth.js";
 export function workspaceRequired(params) {
     const toolLabel = params.toolName ? ` for ${params.toolName}` : "";
     return {
@@ -15,11 +16,13 @@ export function normalizeExplicitWorkspaceId(value) {
     return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 export function workspaceRequestOptions(workspaceId) {
-    const normalized = normalizeExplicitWorkspaceId(workspaceId);
+    const normalized = resolveWorkspaceIdForRequest(normalizeExplicitWorkspaceId(workspaceId), "workspace request options");
     return normalized ? Object.freeze({ workspaceId: normalized }) : undefined;
 }
 export function createWorkspaceContext(input) {
-    const workspaceId = normalizeExplicitWorkspaceId(input.workspaceId);
+    const explicitWorkspaceId = normalizeExplicitWorkspaceId(input.workspaceId);
+    const lockedWorkspaceId = getLockedWorkspaceId();
+    const workspaceId = resolveWorkspaceIdForRequest(explicitWorkspaceId, input.toolName || "workspace context");
     if (!workspaceId) {
         return workspaceRequired({
             executionMode: input.executionMode,
@@ -33,7 +36,9 @@ export function createWorkspaceContext(input) {
         executionMode: input.executionMode,
         toolName: input.toolName,
         runId: input.runId?.trim() || randomUUID(),
-        workspaceResolution: "explicit",
+        workspaceResolution: lockedWorkspaceId && !explicitWorkspaceId
+            ? "locked_profile"
+            : "explicit",
     });
     return { ok: true, context };
 }

package/dist/tools/workspace-export.js

@@ -4,7 +4,7 @@ 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";
+import { getConfig, getEffectiveConfiguredWorkspaceId } from "../auth.js";
 const MAX_FILTER_IDS = 100;
 const MAX_QUERY_LENGTH = 8000;
 export const workspaceExportToolDefinitions = [
@@ -340,7 +340,7 @@ async function writeJsonAtomic(filePath, value) {
 }
 export async function exportWorkspaceCsv(input = {}) {
     const config = getConfig();
-    const workspaceId = config.activeWorkspaceId || config.workspaceId || null;
+    const workspaceId = getEffectiveConfiguredWorkspaceId(config);
     if (!workspaceId) {
         throw new Error("No active workspace selected. Run list_workspaces then set_active_workspace before export_workspace_csv.");
     }

package/dist/tools/workspaces.d.ts

@@ -140,21 +140,56 @@ export declare const workspaceToolDefinitions: ({
 })[];
 export declare function listWorkspaces(): Promise<{
     workspaces: WorkspaceSummary[];
+    workspaceLock: {
+        enabled: boolean;
+        workspaceId?: undefined;
+        hiddenWorkspaceCount?: undefined;
+    };
+} | {
+    workspaces: WorkspaceSummary[];
+    workspaceLock: {
+        enabled: boolean;
+        workspaceId: string;
+        hiddenWorkspaceCount: number;
+    };
 }>;
 export declare function getActiveWorkspace(): {
     activeWorkspaceId: string | null;
     activeWorkspaceName: string | null;
+    workspaceLock: {
+        enabled: boolean;
+        workspaceId: string;
+    } | {
+        enabled: boolean;
+        workspaceId?: undefined;
+    };
 };
 export declare function getWorkspace(workspaceId: string): Promise<{
+    ok: boolean;
+    error: string;
+    workspace?: undefined;
+} | {
     workspace: WorkspaceDetails;
+    ok?: undefined;
+    error?: undefined;
 }>;
 export declare function setActiveWorkspace(workspaceId: string, userConfirmed?: boolean): Promise<{
     ok: boolean;
+    code: string;
+    activeWorkspaceId: string;
+    requestedWorkspaceId: string;
     error: string;
     requiresConfirmation?: undefined;
-    activeWorkspaceId?: undefined;
     activeWorkspaceName?: undefined;
+    requestedWorkspaceName?: undefined;
+} | {
+    ok: boolean;
+    error: string;
+    code?: undefined;
+    activeWorkspaceId?: undefined;
     requestedWorkspaceId?: undefined;
+    requiresConfirmation?: undefined;
+    activeWorkspaceName?: undefined;
     requestedWorkspaceName?: undefined;
 } | {
     ok: boolean;
@@ -164,22 +199,33 @@ export declare function setActiveWorkspace(workspaceId: string, userConfirmed?:
     requestedWorkspaceId: string;
     requestedWorkspaceName: string;
     error: string;
+    code?: undefined;
 } | {
     ok: boolean;
     activeWorkspaceId: string;
     activeWorkspaceName: string;
+    code?: undefined;
+    requestedWorkspaceId?: undefined;
     error?: undefined;
     requiresConfirmation?: undefined;
-    requestedWorkspaceId?: undefined;
     requestedWorkspaceName?: undefined;
 }>;
 export declare function createWorkspace(name: string): Promise<{
+    ok: boolean;
+    code: string;
+    activeWorkspaceId: string;
+    error: string;
+    workspace?: undefined;
+} | {
     workspace: {
         id: string;
         name: string;
         slug: string;
     };
     activeWorkspaceId: string;
+    ok?: undefined;
+    code?: undefined;
+    error?: undefined;
 }>;
 export declare function addTeammate(input: {
     workspaceId?: string;

package/dist/tools/workspaces.js

@@ -1,5 +1,5 @@
 import { getApi, resetApi } from "../api.js";
-import { getConfig, updateActiveWorkspace } from "../auth.js";
+import { getConfig, getEffectiveConfiguredWorkspaceId, getLockedWorkspaceId, resolveWorkspaceIdForRequest, updateActiveWorkspace, } from "../auth.js";
 export const workspaceToolDefinitions = [
     {
         name: "list_workspaces",
@@ -81,21 +81,53 @@ export const workspaceToolDefinitions = [
 export async function listWorkspaces() {
     const api = getApi();
     const { workspaces } = await api.get("/api/v3/workspaces");
-    return { workspaces };
+    const lockedWorkspaceId = getLockedWorkspaceId();
+    if (!lockedWorkspaceId) {
+        return { workspaces, workspaceLock: { enabled: false } };
+    }
+    return {
+        workspaces: workspaces.filter((ws) => ws.id === lockedWorkspaceId),
+        workspaceLock: {
+            enabled: true,
+            workspaceId: lockedWorkspaceId,
+            hiddenWorkspaceCount: workspaces.filter((ws) => ws.id !== lockedWorkspaceId).length,
+        },
+    };
 }
 export function getActiveWorkspace() {
     const config = getConfig();
+    const lockedWorkspaceId = getLockedWorkspaceId();
     return {
-        activeWorkspaceId: config.activeWorkspaceId || config.workspaceId || null,
+        activeWorkspaceId: getEffectiveConfiguredWorkspaceId(config),
         activeWorkspaceName: config.activeWorkspaceName || null,
+        workspaceLock: lockedWorkspaceId
+            ? { enabled: true, workspaceId: lockedWorkspaceId }
+            : { enabled: false },
     };
 }
 export async function getWorkspace(workspaceId) {
+    const allowedWorkspaceId = resolveWorkspaceIdForRequest(workspaceId, "get_workspace");
+    if (!allowedWorkspaceId) {
+        return {
+            ok: false,
+            error: "No active workspace selected.",
+        };
+    }
     const api = getApi();
-    const { workspace } = await api.get(`/api/v3/workspaces/${encodeURIComponent(workspaceId)}`);
+    const { workspace } = await api.get(`/api/v3/workspaces/${encodeURIComponent(allowedWorkspaceId)}`);
     return { workspace };
 }
 export async function setActiveWorkspace(workspaceId, userConfirmed) {
+    const lockedWorkspaceId = getLockedWorkspaceId();
+    if (lockedWorkspaceId && workspaceId !== lockedWorkspaceId) {
+        return {
+            ok: false,
+            code: "WORKSPACE_LOCKED",
+            activeWorkspaceId: lockedWorkspaceId,
+            requestedWorkspaceId: workspaceId,
+            error: "This Hermes profile is locked to its customer workspace and cannot switch workspaces.",
+        };
+    }
     const api = getApi();
     const { workspaces } = await api.get("/api/v3/workspaces");
     const match = workspaces.find((ws) => ws.id === workspaceId);
@@ -131,6 +163,15 @@ export async function setActiveWorkspace(workspaceId, userConfirmed) {
     };
 }
 export async function createWorkspace(name) {
+    const lockedWorkspaceId = getLockedWorkspaceId();
+    if (lockedWorkspaceId) {
+        return {
+            ok: false,
+            code: "WORKSPACE_LOCKED",
+            activeWorkspaceId: lockedWorkspaceId,
+            error: "This Hermes profile is locked to its customer workspace and cannot create or switch workspaces. Use the sellable-admin profile for provisioning.",
+        };
+    }
     const api = getApi();
     const { workspace } = await api.post("/api/v3/workspaces", { name });
     updateActiveWorkspace({
@@ -146,7 +187,9 @@ export async function createWorkspace(name) {
 export async function addTeammate(input) {
     const args = input || {};
     const config = getConfig();
-    const workspaceId = args.workspaceId || config.activeWorkspaceId || config.workspaceId;
+    const workspaceId = resolveWorkspaceIdForRequest(args.workspaceId ||
+        getEffectiveConfiguredWorkspaceId(config) ||
+        undefined, "add_teammate");
     if (!workspaceId) {
         return {
             ok: false,

package/package.json

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

package/skills/create-campaign-v2/references/tier-routing-matrix.md

@@ -59,11 +59,6 @@ The tail MUST verify:
 
 - `attach_recommended_sequence` is the only way to pick a template in
   the autonomous tail. Do NOT hand-wire a sequence at Step 16.
-- Exception: when the parent `$sellable:create-evergreen-campaigns` plan
-  explicitly carries `campaignSequenceOptions:{ mode:"connection_only" }`,
-  do not call `attach_recommended_sequence`. Use the backend-owned
-  `attach_sequence({ tableId, templateRef:"connection_only" })` path and prove
-  `sequenceReceipt.actionTypes:["send_invite"]`.
 - Tier mismatch at attach time is an escalation, NOT a silent fallback.
 - A Standard sender MUST NOT be attached to an INMAIL_OPEN template.
   This would produce sends that fail at Unipile with `not_authorized`.