@sellable/mcp 0.1.531 → 0.1.533

package/dist/auth.d.ts

@@ -38,6 +38,7 @@ export type SkillState = {
  * - "sellable-dev.json" - local development
  */
 export declare function setConfigFile(fileName: string): void;
+export declare function getResolvedConfigsDir(): string | null;
 export declare function getConfigPath(): string;
 export declare function getConfig(): SellableConfig;
 export declare function updateActiveWorkspace(params: {

package/dist/auth.js

@@ -19,9 +19,9 @@ export function setConfigFile(fileName) {
 }
 function getConfigPathCandidates() {
     const candidates = [];
-    const explicitConfigPath = process.env.SELLABLE_CONFIG_PATH?.trim();
+    const explicitConfigPath = getExplicitConfigPath();
     if (explicitConfigPath) {
-        candidates.push(path.resolve(explicitConfigPath));
+        candidates.push(explicitConfigPath);
     }
     if (configFileName === "sellable.json") {
         candidates.push(path.join(os.homedir(), ".sellable", "config.json"));
@@ -34,12 +34,31 @@ function getConfigPathCandidates() {
     candidates.push(path.join(os.homedir(), ".claude", configFileName));
     return Array.from(new Set(candidates));
 }
+function getExplicitConfigPath() {
+    const explicitConfigPath = process.env.SELLABLE_CONFIG_PATH?.trim();
+    return explicitConfigPath ? path.resolve(explicitConfigPath) : null;
+}
+export function getResolvedConfigsDir() {
+    const explicitConfigsDir = process.env.SELLABLE_CONFIGS_DIR?.trim();
+    if (explicitConfigsDir) {
+        return path.resolve(explicitConfigsDir);
+    }
+    const explicitConfigPath = getExplicitConfigPath();
+    if (explicitConfigPath) {
+        return path.join(path.dirname(explicitConfigPath), "configs");
+    }
+    return null;
+}
 function renderConfigPathOrder(candidates) {
     return candidates
         .map((candidate, idx) => `${idx + 1}. ${candidate}`)
         .join("\n");
 }
 export function getConfigPath() {
+    const explicitConfigPath = getExplicitConfigPath();
+    if (explicitConfigPath) {
+        return explicitConfigPath;
+    }
     const candidates = getConfigPathCandidates();
     for (const candidate of candidates) {
         if (fs.existsSync(candidate)) {
@@ -49,9 +68,9 @@ export function getConfigPath() {
     return candidates[0];
 }
 function getConfigWritePath() {
-    const explicitConfigPath = process.env.SELLABLE_CONFIG_PATH?.trim();
+    const explicitConfigPath = getExplicitConfigPath();
     if (explicitConfigPath) {
-        return path.resolve(explicitConfigPath);
+        return explicitConfigPath;
     }
     if (configFileName === "sellable.json") {
         return path.join(os.homedir(), ".sellable", "config.json");

package/dist/refill-run-loop.js

@@ -19,6 +19,34 @@ const REFILL_DONE_REASONS = new Set([
     "not_an_evergreen_workspace",
     "no_refillable_campaigns",
 ]);
+const SCHEDULER_RUN_ENVELOPE_STATUSES = new Set([
+    "ran",
+    "attached",
+    "backoff",
+    "window_closed_noop",
+    "failed",
+]);
+const SCHEDULER_RUN_RECEIPT_STATUSES = new Set([
+    "ran",
+    "window_closed_noop",
+    "failed",
+]);
+const SCHEDULER_RUN_SKIP_REASONS = [
+    "window_closed",
+    "daily_limit",
+    "cooldown",
+    "sender_gate",
+    "credit_threshold",
+    "billing_blocked",
+    "duplicate_lead",
+    "no_senders",
+    "other",
+];
+const SCHEDULER_RUN_HARD_BLOCK_REASONS = new Set([
+    "billing_blocked",
+    "credit_threshold",
+    "cooldown",
+]);
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -40,6 +68,89 @@ function arrayValue(value) {
 function hasBlocker(value, blocker) {
     return isRecord(value) && value.blocker === blocker;
 }
+function schedulerRunSkipReasons(value) {
+    const raw = recordValue(value) ?? {};
+    const normalized = {};
+    for (const reason of SCHEDULER_RUN_SKIP_REASONS) {
+        normalized[reason] = numberValue(raw[reason]) ?? 0;
+    }
+    return normalized;
+}
+function dominantSchedulerRunSkipReason(skipReasons) {
+    let dominant = null;
+    let dominantCount = 0;
+    for (const reason of SCHEDULER_RUN_SKIP_REASONS) {
+        const count = skipReasons[reason] ?? 0;
+        if (count > dominantCount) {
+            dominant = reason;
+            dominantCount = count;
+        }
+    }
+    return dominantCount > 0 ? dominant : null;
+}
+function sanitizeSchedulerRunReceipt(raw) {
+    const envelope = recordValue(raw);
+    if (!envelope)
+        return null;
+    const status = stringValue(envelope.status);
+    if (!status || !SCHEDULER_RUN_ENVELOPE_STATUSES.has(status))
+        return null;
+    const retryAfterMs = envelope.retryAfterMs == null ? null : numberValue(envelope.retryAfterMs);
+    if (envelope.retryAfterMs != null && retryAfterMs == null)
+        return null;
+    const receiptInput = envelope.receipt;
+    let receipt = null;
+    let dominantSkipReason = null;
+    if (receiptInput != null) {
+        const rawReceipt = recordValue(receiptInput);
+        if (!rawReceipt)
+            return null;
+        const receiptStatus = stringValue(rawReceipt.status);
+        if (!receiptStatus || !SCHEDULER_RUN_RECEIPT_STATUSES.has(receiptStatus)) {
+            return null;
+        }
+        const cellsConsidered = numberValue(rawReceipt.cellsConsidered);
+        const cellsScheduled = numberValue(rawReceipt.cellsScheduled);
+        const cellsSkipped = numberValue(rawReceipt.cellsSkipped);
+        const cellsDeferred = numberValue(rawReceipt.cellsDeferred);
+        const tablesFilteredForNoCapacity = numberValue(rawReceipt.tablesFilteredForNoCapacity);
+        if (cellsConsidered == null ||
+            cellsScheduled == null ||
+            cellsSkipped == null ||
+            cellsDeferred == null ||
+            tablesFilteredForNoCapacity == null) {
+            return null;
+        }
+        const skipReasons = schedulerRunSkipReasons(rawReceipt.skipReasons);
+        dominantSkipReason = dominantSchedulerRunSkipReason(skipReasons);
+        receipt = {
+            status: receiptStatus,
+            cellsConsidered,
+            cellsScheduled,
+            cellsSkipped,
+            cellsDeferred,
+            tablesFilteredForNoCapacity,
+            skipReasons,
+        };
+    }
+    return {
+        status,
+        retryAfterMs,
+        receipt,
+        dominantSkipReason,
+        hardBlocked: dominantSkipReason != null &&
+            SCHEDULER_RUN_HARD_BLOCK_REASONS.has(dominantSkipReason),
+    };
+}
+function schedulerRunReceiptIsFreshZeroScheduled(schedulerRunReceipt) {
+    const status = stringValue(schedulerRunReceipt?.status);
+    const fresh = status === "ran" || status === "window_closed_noop";
+    if (!fresh)
+        return false;
+    const receipt = recordValue(schedulerRunReceipt?.receipt);
+    return (status === "window_closed_noop" ||
+        numberValue(receipt?.cellsScheduled) === 0);
+}
 function isLeaseLost(value) {
     return hasBlocker(value, "lease_lost");
 }
@@ -1013,22 +1124,34 @@ async function verifySchedulerWait(input, deps, ctx, action, budgets) {
     const enteredAt = stringValue(progress.schedulerWaitEnteredAt) ??
         (deps.now?.() ?? new Date()).toISOString();
     const jitFired = booleanValue(progress.schedulerJitFired) ?? false;
+    let schedulerRunReceipt = recordValue(progress.schedulerRunReceipt) ?? null;
     if (!jitFired) {
         const senderId = actionSenderId(action);
         if (senderId) {
             await deps.executors.refreshPaidInmailCreditsWithRetry(senderId, input.workspaceId);
         }
         if (deps.requestSchedulerRun) {
-            await deps.requestSchedulerRun(input.workspaceId);
+            try {
+                schedulerRunReceipt = sanitizeSchedulerRunReceipt(await deps.requestSchedulerRun(input.workspaceId));
+            }
+            catch {
+                schedulerRunReceipt = null;
+            }
         }
         ctx.runState = mergeRunState(ctx.runState, {
             progress: mergeProgress(ctx, {
                 schedulerWaitEnteredAt: enteredAt,
                 schedulerJitFired: true,
+                ...(schedulerRunReceipt ? { schedulerRunReceipt } : {}),
             }),
         });
     }
-    for (let poll = 0; poll < budgets.maxSchedulerReadbacks; poll += 1) {
+    const zeroScheduledFresh = schedulerRunReceiptIsFreshZeroScheduled(schedulerRunReceipt);
+    // EDGE-2: the on-demand run only executes placement; cron can still process
+    // due/timed-out cells later. We still do one readback, then avoid burning the
+    // full wait budget when the fresh receipt says nothing was placeable now.
+    const readbackBudget = zeroScheduledFresh ? 1 : budgets.maxSchedulerReadbacks;
+    for (let poll = 0; poll < readbackBudget; poll += 1) {
         const fresh = await deps.readPlan({
             workspaceId: input.workspaceId,
             intent: input.intent,

package/dist/server.js

@@ -45,6 +45,7 @@ import { allTools } from "./tools/registry.js";
 import { getRows, getTableRows, getTableRowsMinimal } from "./tools/rows.js";
 import { addRubricItem, checkRubric, deleteRubricItem, draftRubrics, saveRubrics, selectNecessaryRubrics, updateRubricItem, waitForRubricResults, } from "./tools/rubrics.js";
 import { getSchedulerFillCapacity } from "./tools/scheduler-fill-capacity.js";
+import { runSchedulerSweep } from "./tools/scheduler-run.js";
 import { getSenderRoutingTool, setSenderRoutingTool, } from "./tools/sender-routing.js";
 import { getSender, listSenders, refreshPaidInmailCredits, } from "./tools/senders.js";
 import { attachRecommendedSequence, attachSequence, createWorkflowTable, } from "./tools/sequencer.js";
@@ -235,6 +236,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "get_scheduler_fill_capacity":
                 result = await getSchedulerFillCapacity(args);
                 break;
+            case "run_scheduler_sweep":
+                result = await runSchedulerSweep(args);
+                break;
             case "refill_sends":
                 result = await executeRefillSendsCommand(args);
                 break;

package/dist/tools/auth.d.ts

@@ -2,10 +2,13 @@ import { type SellableUpdateStatus } from "../update-check.js";
 export type AuthStatus = {
     ok: boolean;
     configPath: string;
+    configExists: boolean;
+    configsDir: string | null;
     activeEnvName: string | null;
     apiUrl: string | null;
     activeWorkspaceId: string | null;
     activeWorkspaceName: string | null;
+    tokenPresent: boolean;
     tokenPrefix: string | null;
     workspacesCount: number | null;
     checkedAt: string;

package/dist/tools/auth.js

@@ -1,5 +1,6 @@
+import * as fs from "fs";
 import { getApi, SellableApiError } from "../api.js";
-import { getConfig, getConfigPath } from "../auth.js";
+import { getConfig, getConfigPath, getResolvedConfigsDir } from "../auth.js";
 import { checkForUpdates } from "../update-check.js";
 function maskToken(token) {
     if (token.length <= 10)
@@ -33,15 +34,20 @@ export const authToolDefinitions = [
 ];
 export async function getAuthStatus() {
     const configPath = getConfigPath();
+    const configsDir = getResolvedConfigsDir();
     const checkedAt = new Date().toISOString();
     const update = await getUpdateStatus();
+    let tokenPresent = false;
     const base = {
         ok: false,
         configPath,
+        configExists: fs.existsSync(configPath),
+        configsDir,
         activeEnvName: null,
         apiUrl: null,
         activeWorkspaceId: null,
         activeWorkspaceName: null,
+        tokenPresent: false,
         tokenPrefix: null,
         workspacesCount: null,
         _userNotice: appendUpdateNotice(null, update),
@@ -50,6 +56,7 @@ export async function getAuthStatus() {
     };
     try {
         const config = getConfig();
+        tokenPresent = Boolean(config.token);
         base.activeEnvName = config.activeEnvName || null;
         const api = getApi();
         const { workspaces } = await api.get("/api/v3/workspaces");
@@ -61,6 +68,7 @@ export async function getAuthStatus() {
             return {
                 ...base,
                 apiUrl: config.apiUrl || null,
+                tokenPresent,
                 tokenPrefix: maskToken(config.token),
                 workspacesCount: workspaces.length,
                 error: {
@@ -77,6 +85,7 @@ export async function getAuthStatus() {
             return {
                 ...base,
                 apiUrl: config.apiUrl || null,
+                tokenPresent,
                 tokenPrefix: maskToken(config.token),
                 workspacesCount: workspaces.length,
                 error: {
@@ -97,10 +106,13 @@ export async function getAuthStatus() {
         return {
             ok: true,
             configPath,
+            configExists: fs.existsSync(configPath),
+            configsDir,
             activeEnvName: envLabel,
             apiUrl: config.apiUrl || null,
             activeWorkspaceId,
             activeWorkspaceName: workspaceName,
+            tokenPresent,
             tokenPrefix: maskToken(config.token),
             workspacesCount: workspaces.length,
             _userNotice: appendUpdateNotice(notice, update),
@@ -124,7 +136,7 @@ export async function getAuthStatus() {
             "  3. Click it, come back here, and we'll keep going\\n\\n" +
             "What email should I use?` " +
             "2) Wait for the user to type their email in normal chat (do NOT use AskUserQuestion / request_user_input). " +
-            "3) Call `mcp__sellable__start_cli_login({ email })` with that email. " +
+            "3) Call `mcp__sellable__start_cli_login({ email })` with that email in Claude Code/Codex, or `mcp_sellable_start_cli_login({ email })` in Hermes. " +
             "4) On `ok: true`, say verbatim (substituting the email exactly as typed):\\n" +
             "`Magic link sent to {email}.\\n\\n" +
             "─────────────────────────────────────────────\\n" +
@@ -135,14 +147,15 @@ export async function getAuthStatus() {
             "  3. Come back here when you're done\\n\\n" +
             "I'll be waiting right here.\\n\\n" +
             "  (If your team already uses Sellable, ask an admin to invite you into their shared workspace instead — that gets you straight in.)` " +
-            "5) Call `mcp__sellable__wait_for_cli_login({ sessionId })` using the sessionId returned by start_cli_login. " +
-            "6) If the result is `error.type === 'tool_timeout_guard'`, IMMEDIATELY re-call wait_for_cli_login with the SAME sessionId — do not narrate, do not call start_cli_login again. Loop until you get a different result. " +
-            "7) On `ok: true`, the user is signed in and `~/.sellable/config.json` has been written. Branch on `isReturningUser` and use `activeWorkspaceName` when present, otherwise `activeWorkspaceId`, as `{workspaceLabel}`: " +
+            "5) Call `mcp__sellable__wait_for_cli_login({ sessionId })` in Claude Code/Codex, or `mcp_sellable_wait_for_cli_login({ sessionId })` in Hermes, using the sessionId returned by start_cli_login. " +
+            "6) If the result is `error.type === 'tool_timeout_guard'`, IMMEDIATELY re-call wait_for_cli_login with the SAME sessionId — do not narrate, do not call start_cli_login again. In Hermes, re-call `mcp_sellable_wait_for_cli_login({ sessionId })`. Loop until you get a different result. " +
+            `7) On \`ok: true\`, the user is signed in and the resolved Sellable config file has been written at ${configPath}. Branch on \`isReturningUser\` and use \`activeWorkspaceName\` when present, otherwise \`activeWorkspaceId\`, as \`{workspaceLabel}\`: ` +
             "if true, say `You're in {workspaceLabel}.\\n\\nExcited to help you launch your LinkedIn outbound campaign. We're at setup: first I'll use your LinkedIn profile to understand the company, then I'll draft the campaign brief, help choose where to find buyers, review messages, and wait for final launch approval.\\n\\nWhat's your LinkedIn profile URL or handle?`; " +
             "if false, say `You're set up in {workspaceLabel}.\\n\\nExcited to help you launch your LinkedIn outbound campaign. We're at setup: first I'll use your LinkedIn profile to understand the company, then I'll draft the campaign brief, help choose where to find buyers, review messages, and wait for final launch approval.\\n\\nWhat's your LinkedIn profile URL or handle?`";
         if (error instanceof SellableApiError && error.isAuthError) {
             return {
                 ...base,
+                tokenPresent,
                 error: {
                     type: "auth",
                     status: error.status,
@@ -162,6 +175,7 @@ export async function getAuthStatus() {
             : `Fix the configuration in ${configPath}, then retry get_auth_status.`;
         return {
             ...base,
+            tokenPresent,
             error: {
                 type: isConfigError ? "config" : "api",
                 message,

package/dist/tools/bootstrap.js

@@ -307,7 +307,7 @@ export async function bootstrapCreateCampaign(input = {}) {
         ? resumeDetected
             ? `Bootstrap complete.${workspaceNotice}${modelNotice} Resume from campaign state and navigation diagnostics first; treat local draft artifacts as debug-only evidence. Then load ${createCampaignSubskill?.name ?? "create-campaign"} instructions with get_subskill_prompt({ subskillName: "${createCampaignSubskill?.name ?? "create-campaign"}" }); if the response has hasMore=true, continue with nextOffset until hasMore=false.`
             : flowVersion === "v2"
-                ? `Bootstrap complete.${workspaceNotice}${modelNotice} Load the compact create-campaign-v2 entry prompt once with get_subskill_prompt({ subskillName: "create-campaign-v2" }); load flow/reference assets lazily only when that stage needs them. Preserve the pre-intake sequence: confirm auth/workspace status, ask only for the LinkedIn profile URL or handle, normalize handles to a full profile URL, require that profile identity before continuing, run lightweight profile/company lookup, then ask the target, offer, credibility, and prospect-source setup questions. Do not call list_senders or sender discovery during setup; sender availability belongs only to Settings after message approval. Then write the campaign brief, call create_campaign once to mint the watchable shell, surface the returned watch link once before brief approval, and hand off to lead finding without repeating the link.`
+                ? `Bootstrap complete.${workspaceNotice}${modelNotice} Load the compact create-campaign-v2 entry prompt once with get_subskill_prompt({ subskillName: "create-campaign-v2" }); Hermes users should start this flow with /sellable-create-campaign. Load flow/reference assets lazily only when that stage needs them. Preserve the pre-intake sequence: confirm auth/workspace status, ask only for the LinkedIn profile URL or handle, normalize handles to a full profile URL, require that profile identity before continuing, run lightweight profile/company lookup, then ask the target, offer, credibility, and prospect-source setup questions. Do not call list_senders or sender discovery during setup; sender availability belongs only to Settings after message approval. Then write the campaign brief, call create_campaign once to mint the watchable shell, surface the returned watch link once before brief approval, and hand off to lead finding without repeating the link.`
                 : `Bootstrap complete.${workspaceNotice}${modelNotice} Load ${createCampaignSubskill?.name ?? "create-campaign"} instructions with get_subskill_prompt({ subskillName: "${createCampaignSubskill?.name ?? "create-campaign"}" }); if the response has hasMore=true, continue with nextOffset until hasMore=false. Follow that flow before calling create_campaign.`
         : "Bootstrap incomplete. Resolve blockingErrors and rerun bootstrap_create_campaign before provider/search/import tools.";
     // Strip prompt body from createCampaignSubskill — it's loaded via the host

package/dist/tools/campaigns.d.ts

@@ -9,9 +9,9 @@ declare const LEAD_SOURCE_PROVIDERS: {
 };
 type LeadSourceProvider = (typeof LEAD_SOURCE_PROVIDERS)[keyof typeof LEAD_SOURCE_PROVIDERS];
 export declare function buildWatchUrl(config: Pick<ReturnType<typeof getConfig>, "apiUrl" | "token" | "activeWorkspaceId" | "workspaceId">, path: string): string;
-export type CampaignBuilderWatchMode = "claude" | "codex";
+export type CampaignBuilderWatchMode = "claude" | "codex" | "hermes";
 export declare function getCampaignBuilderWatchModeParam(): CampaignBuilderWatchMode;
-export declare function getCampaignBuilderWatchModeDriverLabel(mode?: CampaignBuilderWatchMode): "Claude Code" | "Codex";
+export declare function getCampaignBuilderWatchModeDriverLabel(mode?: CampaignBuilderWatchMode): "Claude Code" | "Codex" | "Hermes";
 export declare function buildCampaignWatchHandoffMarkdown(watchUrl: string, mode?: CampaignBuilderWatchMode): string;
 export interface Campaign {
     id: string;

package/dist/tools/campaigns.js

@@ -124,23 +124,35 @@ export function buildWatchUrl(config, path) {
     }
     return url.toString();
 }
+const CAMPAIGN_BUILDER_AGENT_WATCH_MODES = new Set([
+    "claude",
+    "codex",
+    "hermes",
+]);
 export function getCampaignBuilderWatchModeParam() {
     const explicit = process.env.SELLABLE_WATCH_MODE_DRIVER?.trim().toLowerCase();
-    if (explicit === "claude" || explicit === "codex")
+    if (CAMPAIGN_BUILDER_AGENT_WATCH_MODES.has(explicit)) {
         return explicit;
+    }
     return process.env.CODEX_HOME ? "codex" : "claude";
 }
 function getCampaignBuilderWatchModeFromUrl(watchUrl) {
     try {
         const mode = new URL(watchUrl).searchParams.get("mode");
-        return mode === "claude" || mode === "codex" ? mode : null;
+        return CAMPAIGN_BUILDER_AGENT_WATCH_MODES.has(mode)
+            ? mode
+            : null;
     }
     catch {
         return null;
     }
 }
 export function getCampaignBuilderWatchModeDriverLabel(mode = getCampaignBuilderWatchModeParam()) {
-    return mode === "codex" ? "Codex" : "Claude Code";
+    if (mode === "codex")
+        return "Codex";
+    if (mode === "hermes")
+        return "Hermes";
+    return "Claude Code";
 }
 export function buildCampaignWatchHandoffMarkdown(watchUrl, mode = getCampaignBuilderWatchModeFromUrl(watchUrl) ?? getCampaignBuilderWatchModeParam()) {
     const driverLabel = getCampaignBuilderWatchModeDriverLabel(mode);
@@ -161,7 +173,7 @@ function isValidBriefHandoffWatchUrl(watchUrl, campaignId) {
         const url = new URL(watchUrl);
         const mode = url.searchParams.get("mode");
         return (url.pathname === `/campaign-builder/${campaignId}` &&
-            (mode === "claude" || mode === "codex") &&
+            CAMPAIGN_BUILDER_AGENT_WATCH_MODES.has(mode) &&
             Boolean(url.searchParams.get("workspaceId")) &&
             Boolean(url.searchParams.get("token")));
     }
@@ -173,7 +185,7 @@ function assertBriefHandoffWatchUrl(watchUrl, campaignId) {
     if (isValidBriefHandoffWatchUrl(watchUrl, campaignId))
         return;
     throw new Error("create_campaign produced an invalid watchUrl for the brief approval handoff. " +
-        "Recover a fresh direct /campaign-builder/{campaignId}?mode={claude|codex}&workspaceId=...&token=... URL " +
+        "Recover a fresh direct /campaign-builder/{campaignId}?mode={claude|codex|hermes}&workspaceId=...&token=... URL " +
         "with create_campaign({ campaignId }) or get_campaign before asking for approval.");
 }
 export const campaignToolDefinitions = [

package/dist/tools/model-quality.d.ts

@@ -1,4 +1,4 @@
-export type CampaignModelHost = "claude" | "codex" | "unknown";
+export type CampaignModelHost = "claude" | "codex" | "hermes" | "unknown";
 export type CampaignModelQualityInput = {
     host?: string | null;
     model?: string | null;
@@ -33,6 +33,7 @@ export type CampaignModelQualityConfig = {
     hosts: {
         claude: CampaignModelQualityHostConfig;
         codex: CampaignModelQualityHostConfig;
+        hermes: CampaignModelQualityHostConfig;
     };
     warningCopy: {
         ok: string;

package/dist/tools/model-quality.js

@@ -30,6 +30,20 @@ const DEFAULT_MODEL_QUALITY_CONFIG = {
             ],
             recommendedReasoningEffort: "xhigh",
         },
+        hermes: {
+            label: "Hermes",
+            minimumModel: "GPT 5.5",
+            familyKeywords: ["gpt"],
+            minimumVersion: "5.5",
+            minimumReasoningEffort: "xhigh",
+            acceptedReasoningEfforts: [
+                "extra high",
+                "extra-high",
+                "xhigh",
+                "extra_high",
+            ],
+            recommendedReasoningEffort: "xhigh",
+        },
     },
     warningCopy: {
         ok: "Active host model metadata meets the configured campaign floor: {currentSettings}.",
@@ -41,6 +55,8 @@ const TRUSTED_METADATA_SOURCE_KEYWORDS = [
     "codex_turn_metadata",
     "claude_runtime_metadata",
     "claude_session_context",
+    "hermes_runtime_metadata",
+    "hermes_session_context",
     "active_turn_metadata",
     "user_confirmed",
 ];
@@ -49,6 +65,9 @@ const normalize = (value) => String(value ?? "")
     .toLowerCase();
 const normalizeHost = (host) => {
     const normalized = normalize(host);
+    if (normalized.includes("hermes")) {
+        return "hermes";
+    }
     if (normalized.includes("claude") ||
         normalized.includes("opus") ||
         normalized.includes("sonnet") ||
@@ -114,6 +133,7 @@ function findHostConfig(host, model, config) {
         ? [
             ["claude", config.hosts.claude],
             ["codex", config.hosts.codex],
+            ["hermes", config.hosts.hermes],
         ]
         : [[host, config.hosts[host]]];
     return candidates.find(([, hostConfig]) => modelMeetsMinimum(model, hostConfig, {
@@ -130,7 +150,7 @@ export function evaluateCampaignModelQuality(input = {}) {
     const model = input.model?.trim() || null;
     const reasoningEffort = input.reasoningEffort?.trim() || null;
     const metadataSource = input.metadataSource?.trim() || null;
-    const recommendationHost = host === "claude" ? "claude" : "codex";
+    const recommendationHost = host === "claude" || host === "hermes" ? host : "codex";
     const recommendedHostConfig = config.hosts[recommendationHost];
     const minimumSummary = getCampaignModelMinimumSummary(config);
     const currentSettings = [

package/dist/tools/refill-sends-evergreen.d.ts

@@ -0,0 +1,28 @@
+type RefillSendsEvergreenInput = {
+    workspaceId?: string;
+};
+export declare const refillSendsEvergreenToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            workspaceId: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+}[];
+export declare function refillSendsEvergreenCommand(input: RefillSendsEvergreenInput): {
+    readOnly: boolean;
+    workspaceId: string | null;
+    firstOperationalSteps: string[];
+    approvalContract: string;
+    forbiddenActions: string[];
+    fillWindow: string;
+    hostExamples: string[];
+};
+export {};

package/dist/tools/refill-sends-evergreen.js

@@ -0,0 +1,47 @@
+export const refillSendsEvergreenToolDefinitions = [
+    {
+        name: "refill_sends_evergreen",
+        description: "Read-only Phase 85 evergreen refill command contract. It performs no mutations and only tells the operator to call get_evergreen_refill_plan for a dry-run packet and journal.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                workspaceId: {
+                    type: "string",
+                    description: "Explicit request-scoped workspace id.",
+                },
+            },
+            required: ["workspaceId"],
+            additionalProperties: false,
+        },
+    },
+];
+export function refillSendsEvergreenCommand(input) {
+    return {
+        readOnly: true,
+        workspaceId: input.workspaceId ?? null,
+        firstOperationalSteps: [
+            "Call get_evergreen_refill_plan with the explicit workspaceId.",
+            "Read the returned packet, globalActionQueue, per-sender plans, and itinerary before taking any action.",
+            "Review the dry-run journal file path returned by get_evergreen_refill_plan.",
+            "Phase 85 is PLAN-ONLY; execution arrives in Phase 86.",
+        ],
+        approvalContract: "Nothing is approved or executable in Phase 85. The evergreen command is read-only; Phase 86 introduces execution approval.",
+        forbiddenActions: [
+            "Do not schedule sends.",
+            "Do not send messages.",
+            "Do not approve messages.",
+            "Do not prepare messages.",
+            "Do not start or launch campaigns.",
+            "Do not create campaigns.",
+            "Do not switch providers or source families.",
+            "Do not lower paid InMail thresholds.",
+            "Do not refresh paid InMail credits.",
+            "Do not write scheduler fields.",
+        ],
+        fillWindow: "Use only the target window and caps returned by get_evergreen_refill_plan.",
+        hostExamples: [
+            "refill_sends_evergreen({ workspaceId })",
+            "get_evergreen_refill_plan({ workspaceId })",
+        ],
+    };
+}

package/dist/tools/refill-sends-v2.js

@@ -5,6 +5,7 @@ import { runRefillV2Loop } from "../refill-run-loop.js";
 import { getPrepareCampaignMessagesStatus } from "./campaign-message-preparation.js";
 import { getRefillPlanV2 } from "./evergreen-refill-plan.js";
 import { executeOneYoloPrimitive, executeStartCampaignPrimitive, prepareRowSelectorValue, refillPrepareRequestHash, refreshPaidInmailCreditsWithRetry, } from "./refill-executors.js";
+import { runSchedulerSweep } from "./scheduler-run.js";
 const FORBIDDEN_ACTIONS = [
     "Do not schedule sends.",
     "Do not send messages.",
@@ -152,6 +153,7 @@ export async function refillSendsV2Command(input) {
         localState: {
             writeRefillWorkspaceState,
         },
+        requestSchedulerRun: (workspaceId) => runSchedulerSweep({ workspaceId, action: "run" }),
     });
     return {
         ...(await maybeAddLostFenceGuidance(result, { ...input, workspaceId })),

package/dist/tools/registry.d.ts

@@ -7370,6 +7370,25 @@ export declare const allTools: ({
         };
         required: string[];
     };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            workspaceId: {
+                type: string;
+                description: string;
+            };
+            action: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
 } | {
     name: string;
     description: string;

package/dist/tools/registry.js

@@ -40,6 +40,7 @@ import { refillTargetPlanToolDefinitions } from "./refill-target-plan.js";
 import { rowToolDefinitions } from "./rows.js";
 import { rubricToolDefinitions } from "./rubrics.js";
 import { schedulerFillCapacityToolDefinitions } from "./scheduler-fill-capacity.js";
+import { schedulerRunToolDefinitions } from "./scheduler-run.js";
 import { senderRoutingToolDefinitions } from "./sender-routing.js";
 import { senderToolDefinitions } from "./senders.js";
 import { sequencerToolDefinitions } from "./sequencer.js";
@@ -57,6 +58,7 @@ export const allTools = [
     ...refillPlanV2ToolDefinitions,
     ...refillTargetPlanToolDefinitions,
     ...schedulerFillCapacityToolDefinitions,
+    ...schedulerRunToolDefinitions,
     ...refillSendsToolDefinitions,
     ...refillSendsV2ToolDefinitions,
     ...setupEvergreenCampaignsToolDefinitions,

package/dist/tools/scheduler-run.d.ts

@@ -0,0 +1,27 @@
+type SchedulerRunAction = "run" | "status";
+type RunSchedulerSweepInput = {
+    workspaceId: string;
+    action?: SchedulerRunAction;
+};
+export declare const schedulerRunToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            workspaceId: {
+                type: string;
+                description: string;
+            };
+            action: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+}[];
+export declare function runSchedulerSweep(input: RunSchedulerSweepInput): Promise<unknown>;
+export {};

package/dist/tools/scheduler-run.js

@@ -0,0 +1,45 @@
+import { getApi } from "../api.js";
+import { normalizeExplicitWorkspaceId, workspaceRequestOptions, } from "./workspace-context.js";
+async function postSchedulerRun(body, workspaceId) {
+    const api = getApi();
+    const requestOptions = workspaceRequestOptions(workspaceId);
+    return requestOptions
+        ? api.post("/api/v3/mcp/scheduler-run", body, requestOptions)
+        : api.post("/api/v3/mcp/scheduler-run", body);
+}
+export const schedulerRunToolDefinitions = [
+    {
+        name: "run_scheduler_sweep",
+        description: 'Trigger the product scheduler placement sweep for one explicit workspace now, or read the last on-demand scheduler run status with action "status". A run returns a synchronous envelope with status ran, attached, backoff, window_closed_noop, or failed; retryAfterMs for backoff replays; and a receipt with cellsConsidered, cellsScheduled, cellsSkipped, cellsDeferred, deterministic skipReasons, and tablesFilteredForNoCapacity. It places cells within existing scheduler gates only: it can move placement earlier, but it cannot bypass sending windows, daily limits, cooldowns, sender gates, billing, or credit thresholds, and it never sends messages directly. Repeated calls inside the backoff window replay the last receipt verbatim. Status is read-only and scoped to the last on-demand run only; cron sweeps are not recorded here.',
+        inputSchema: {
+            type: "object",
+            properties: {
+                workspaceId: {
+                    type: "string",
+                    description: "Explicit request-scoped workspace id for scheduled/yolo refill automation. Pass this instead of switching the shared active workspace.",
+                },
+                action: {
+                    type: "string",
+                    enum: ["run", "status"],
+                    description: 'Use "run" to trigger a placement sweep now. Use "status" for a read-only view of the last on-demand run. Defaults to "run".',
+                },
+            },
+            required: ["workspaceId"],
+            additionalProperties: false,
+        },
+    },
+];
+export async function runSchedulerSweep(input) {
+    const workspaceId = normalizeExplicitWorkspaceId(input.workspaceId);
+    if (!workspaceId) {
+        throw new Error("workspaceId is required for run_scheduler_sweep.");
+    }
+    const action = input.action ?? "run";
+    if (action !== "run" && action !== "status") {
+        throw new Error('action must be "run" or "status" for run_scheduler_sweep.');
+    }
+    return postSchedulerRun({
+        workspaceId,
+        action,
+    }, workspaceId);
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@sellable/mcp",
-  "version": "0.1.531",
+  "version": "0.1.533",
   "type": "module",
-  "description": "Sellable MCP server for Claude Code and Codex campaign workflows",
+  "description": "Sellable MCP server for Claude Code, Codex, and Hermes campaign workflows",
   "main": "dist/index.js",
   "bin": {
     "mcp": "dist/index.js",
@@ -20,6 +20,7 @@
     "mcp",
     "claude-code",
     "codex",
+    "hermes",
     "sellable",
     "linkedin",
     "outreach"

package/skills/refill-sends/SKILL.md

@@ -6,6 +6,7 @@ allowed-tools:
   - mcp__sellable__refill_sends
   - mcp__sellable__get_refill_target_plan
   - mcp__sellable__get_scheduler_fill_capacity
+  - mcp__sellable__run_scheduler_sweep
   - mcp__sellable__refresh_paid_inmail_credits
   - mcp__sellable__get_subskill_asset
   - mcp__sellable__get_auth_status
@@ -114,10 +115,11 @@ 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.
+`get_campaign_refill_state`, `get_scheduler_fill_capacity`,
+`run_scheduler_sweep`, 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
@@ -269,6 +271,10 @@ need raw proof, call the read-only `get_scheduler_fill_capacity` query for the
 same sender/action/date; it tells the MCP how many cells the product scheduler
 will try to place and does not import, approve, schedule, refresh credits, or
 mutate.
+When the refill loop has ready rows and needs scheduler pickup now, use
+`run_scheduler_sweep` with the same explicit `workspaceId`; it can place cells
+within existing scheduler gates and returns the receipt, but it never sends or
+bypasses limits.
 If the target plan is complete by projected coverage, report that the selected
 target is already filled and no-op without asking for approval. If the ready
 buffer covers the projected gap, paid InMail credit facts are fresh for every

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

@@ -6,6 +6,7 @@ allowed-tools:
   - mcp__sellable__get_subskill_asset
   - mcp__sellable__get_refill_target_plan
   - mcp__sellable__get_scheduler_fill_capacity
+  - mcp__sellable__run_scheduler_sweep
   - mcp__sellable__refresh_paid_inmail_credits
   - mcp__sellable__list_senders
   - mcp__sellable__get_sender_routing
@@ -67,11 +68,12 @@ 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.
+`run_scheduler_sweep`, `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
@@ -186,6 +188,10 @@ files or memory.
    how many cells the product scheduler will try to place for that sender; it
    does not create rows, import, approve, schedule, refresh paid-InMail credits,
    or mutate thresholds.
+   When ready rows exist and the wait is for scheduler pickup, call
+   `run_scheduler_sweep` with the same explicit `workspaceId` to request the
+   product scheduler placement pass now and read its receipt. This may place
+   cells within existing gates, never sends messages, and never bypasses limits.
    If `status:"complete"`, report the target, selected dates, sent count,
    scheduled count, projected count, campaign ids, and no-op proof without
    asking for approval or mutating.

package/skills/research/config.json

@@ -0,0 +1,9 @@
+{
+  "parallelMode": "wide",
+  "agentCount": 6,
+  "maxToolCallsPerAgent": 2,
+  "senderMaxAgents": 2,
+  "senderMaxToolCallsPerAgent": 3,
+  "progressMode": true,
+  "debugMode": true
+}