@sellable/mcp 0.1.560 → 0.1.561-hermes031.202607110338

package/dist/refill-date-window.d.ts

@@ -0,0 +1,34 @@
+export type RefillDateWindowSource = "default_scheduler_forward" | "horizon_send_days" | "until_date" | "target_date";
+export type NormalizedRefillDateSelector = {
+    source: RefillDateWindowSource;
+    targetDate: string | null;
+    untilDate: string | null;
+    horizonSendDays: number | null;
+};
+export type RefillRunDateWindow = NormalizedRefillDateSelector & {
+    version: 1;
+    selectedDates: string[];
+    senderWindows?: Array<{
+        senderId: string | null;
+        timeZone: string | null;
+        selectedDates: string[];
+    }>;
+};
+type DateSelectorInput = {
+    targetDate?: unknown;
+    untilDate?: unknown;
+    horizonSendDays?: unknown;
+};
+export declare function normalizeRefillDateSelector(input: DateSelectorInput): NormalizedRefillDateSelector;
+export declare function refillDateSelectorBody(selector: NormalizedRefillDateSelector): {
+    targetDate?: string;
+    untilDate?: string;
+    horizonSendDays?: number;
+};
+export declare function dateWindowFromSelector(selector: NormalizedRefillDateSelector): RefillRunDateWindow;
+export declare function dateWindowFromPlan(plan: Record<string, unknown>, selector: NormalizedRefillDateSelector): RefillRunDateWindow;
+export declare function dateWindowFromRunState(runState: unknown): RefillRunDateWindow | null;
+export declare function selectorFromDateWindow(window: RefillRunDateWindow): NormalizedRefillDateSelector;
+export declare function dateSelectorMatchesWindow(selector: NormalizedRefillDateSelector, window: RefillRunDateWindow): boolean;
+export declare function schedulerSweepTargetDates(window: RefillRunDateWindow): string[];
+export {};

package/dist/refill-date-window.js

@@ -0,0 +1,210 @@
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function arrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}
+function isValidDateKey(value) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+        return false;
+    const [year, month, day] = value.split("-").map(Number);
+    const date = new Date(Date.UTC(year, month - 1, day));
+    return (date.getUTCFullYear() === year &&
+        date.getUTCMonth() === month - 1 &&
+        date.getUTCDate() === day);
+}
+function normalizeDateKey(value, field) {
+    if (value === undefined || value === null || value === "")
+        return null;
+    if (typeof value !== "string") {
+        throw new Error(`${field} must be a string in YYYY-MM-DD format.`);
+    }
+    const trimmed = value.trim();
+    if (!isValidDateKey(trimmed)) {
+        throw new Error(`${field} must be a valid YYYY-MM-DD calendar date.`);
+    }
+    return trimmed;
+}
+function normalizeHorizonSendDays(value) {
+    if (value === undefined)
+        return null;
+    if (typeof value !== "number" ||
+        !Number.isInteger(value) ||
+        value < 1 ||
+        value > 7) {
+        throw new Error("horizonSendDays must be an integer between 1 and 7.");
+    }
+    return value;
+}
+export function normalizeRefillDateSelector(input) {
+    const targetDate = normalizeDateKey(input.targetDate, "targetDate");
+    const untilDate = normalizeDateKey(input.untilDate, "untilDate");
+    const horizonSendDays = normalizeHorizonSendDays(input.horizonSendDays);
+    if (targetDate) {
+        return {
+            source: "target_date",
+            targetDate,
+            untilDate: null,
+            horizonSendDays: null,
+        };
+    }
+    if (untilDate) {
+        return {
+            source: "until_date",
+            targetDate: null,
+            untilDate,
+            horizonSendDays: null,
+        };
+    }
+    if (horizonSendDays !== null) {
+        return {
+            source: "horizon_send_days",
+            targetDate: null,
+            untilDate: null,
+            horizonSendDays,
+        };
+    }
+    return {
+        source: "default_scheduler_forward",
+        targetDate: null,
+        untilDate: null,
+        horizonSendDays: null,
+    };
+}
+export function refillDateSelectorBody(selector) {
+    if (selector.source === "target_date" && selector.targetDate) {
+        return { targetDate: selector.targetDate };
+    }
+    if (selector.source === "until_date" && selector.untilDate) {
+        return { untilDate: selector.untilDate };
+    }
+    if (selector.source === "horizon_send_days" &&
+        selector.horizonSendDays !== null) {
+        return { horizonSendDays: selector.horizonSendDays };
+    }
+    return {};
+}
+export function dateWindowFromSelector(selector) {
+    return {
+        version: 1,
+        ...selector,
+        selectedDates: selector.targetDate ? [selector.targetDate] : [],
+    };
+}
+function selectedDatesFromPlan(plan) {
+    const packet = isRecord(plan.packet) ? plan.packet : {};
+    const target = isRecord(packet.target) ? packet.target : {};
+    const window = isRecord(target.window) ? target.window : {};
+    const senderWindows = arrayValue(window.senderWindows).filter(isRecord);
+    const fromWindows = senderWindows.flatMap((senderWindow) => arrayValue(senderWindow.selectedDates)
+        .map((entry) => stringValue(entry))
+        .filter((entry) => Boolean(entry)));
+    if (fromWindows.length > 0)
+        return Array.from(new Set(fromWindows)).sort();
+    const senderRefillPlans = arrayValue(target.senderRefillPlans).filter(isRecord);
+    return Array.from(new Set(senderRefillPlans.flatMap((senderPlan) => {
+        const horizon = isRecord(senderPlan.horizon) ? senderPlan.horizon : {};
+        return arrayValue(horizon.selectedDays)
+            .filter(isRecord)
+            .map((day) => stringValue(day.date))
+            .filter((entry) => Boolean(entry));
+    }))).sort();
+}
+function senderWindowsFromPlan(plan) {
+    const packet = isRecord(plan.packet) ? plan.packet : {};
+    const target = isRecord(packet.target) ? packet.target : {};
+    const window = isRecord(target.window) ? target.window : {};
+    return arrayValue(window.senderWindows)
+        .filter(isRecord)
+        .map((senderWindow) => ({
+        senderId: stringValue(senderWindow.senderId),
+        timeZone: stringValue(senderWindow.timeZone),
+        selectedDates: arrayValue(senderWindow.selectedDates)
+            .map((entry) => stringValue(entry))
+            .filter((entry) => Boolean(entry)),
+    }));
+}
+export function dateWindowFromPlan(plan, selector) {
+    const packet = isRecord(plan.packet) ? plan.packet : {};
+    const request = isRecord(packet.request) ? packet.request : {};
+    const targetDate = stringValue(request.targetDate) ?? selector.targetDate ?? null;
+    const untilDate = stringValue(request.untilDate) ?? selector.untilDate ?? null;
+    const horizonSendDays = numberValue(request.horizonSendDays) ?? selector.horizonSendDays ?? null;
+    const source = targetDate
+        ? "target_date"
+        : untilDate
+            ? "until_date"
+            : horizonSendDays !== null
+                ? "horizon_send_days"
+                : selector.source;
+    const selectedDates = selectedDatesFromPlan(plan);
+    return {
+        version: 1,
+        source,
+        targetDate: source === "target_date" ? targetDate : null,
+        untilDate: source === "until_date" ? untilDate : null,
+        horizonSendDays: source === "horizon_send_days" ? horizonSendDays : null,
+        selectedDates: selectedDates.length > 0
+            ? selectedDates
+            : targetDate
+                ? [targetDate]
+                : [],
+        senderWindows: senderWindowsFromPlan(plan),
+    };
+}
+export function dateWindowFromRunState(runState) {
+    const state = isRecord(runState) ? runState : {};
+    const raw = isRecord(state.dateWindow) ? state.dateWindow : null;
+    if (!raw || raw.version !== 1)
+        return null;
+    const source = raw.source === "target_date" ||
+        raw.source === "until_date" ||
+        raw.source === "horizon_send_days" ||
+        raw.source === "default_scheduler_forward"
+        ? raw.source
+        : null;
+    if (!source)
+        return null;
+    return {
+        version: 1,
+        source,
+        targetDate: source === "target_date" ? stringValue(raw.targetDate) : null,
+        untilDate: source === "until_date" ? stringValue(raw.untilDate) : null,
+        horizonSendDays: source === "horizon_send_days"
+            ? numberValue(raw.horizonSendDays)
+            : null,
+        selectedDates: arrayValue(raw.selectedDates)
+            .map((entry) => stringValue(entry))
+            .filter((entry) => Boolean(entry)),
+    };
+}
+export function selectorFromDateWindow(window) {
+    return {
+        source: window.source,
+        targetDate: window.targetDate,
+        untilDate: window.untilDate,
+        horizonSendDays: window.horizonSendDays,
+    };
+}
+export function dateSelectorMatchesWindow(selector, window) {
+    return (selector.source === window.source &&
+        selector.targetDate === window.targetDate &&
+        selector.untilDate === window.untilDate &&
+        selector.horizonSendDays === window.horizonSendDays);
+}
+export function schedulerSweepTargetDates(window) {
+    if (window.source === "target_date" && window.targetDate) {
+        return [window.targetDate];
+    }
+    if (window.source === "until_date" ||
+        window.source === "horizon_send_days") {
+        return window.selectedDates;
+    }
+    return [];
+}

package/dist/refill-run-loop.js

@@ -1027,23 +1027,6 @@ async function gatePlan(input, deps, ctx) {
         fallbackSummary: line.fallbackSummary,
     }));
     const fingerprint = fingerprintFromPlan(plan);
-    const approvedTargetShapeRevision = stringValue(input.approval?.targetShapeRevision);
-    if (approvedTargetShapeRevision &&
-        approvedTargetShapeRevision !== fingerprint.targetShapeRevision) {
-        return {
-            status: "blocked",
-            blocker: "scope_drift",
-            runId: ctx.runId,
-            fence: ctx.fence,
-            gate: ctx.gate,
-            guidance: "The canonical refill target shape changed after approval; render a new packet before another primitive.",
-            report: {
-                approvedTargetShapeRevision,
-                freshTargetShapeRevision: fingerprint.targetShapeRevision,
-            },
-            journalPath: ctx.journalPath,
-        };
-    }
     const persistedCircuit = recordValue(runStateProgress(ctx).prepCircuit);
     if (stringValue(action.type) === "prepare_messages" &&
         openCircuitWaits(persistedCircuit, deps.now?.() ?? new Date())) {

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.d.ts

@@ -167,17 +167,6 @@ export declare function prepareRefillSendsV2Approval(input: RefillV2ApprovalPrep
     response?: undefined;
 }>;
 export declare function refillSendsV2Command(input: RefillSendsV2Input): Promise<{
-    status: "blocked";
-    blocker: "approval_expired" | "approval_fingerprint_mismatch";
-    guidance: string;
-    report: {
-        fresh?: {} | null | undefined;
-        changed: string[];
-    };
-    readOnly: boolean;
-    forbiddenActions: string[];
-    boundedAuthority: string;
-} | {
     readOnly: boolean;
     mode: string;
     forbiddenActions: string[];

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

@@ -325,11 +325,7 @@ function validateApprovalEcho(envelope, echo, now = new Date()) {
     ];
     const changed = fields.filter((field) => echo[field] !== envelope.approval[field]);
     if (Date.parse(envelope.approval.approvalExpiresAt) <= now.getTime()) {
-        return {
-            ok: false,
-            blocker: "approval_expired",
-            changed,
-        };
+        return { ok: false, blocker: "approval_expired", changed };
     }
     return changed.length === 0
         ? { ok: true }
@@ -339,85 +335,6 @@ function validateApprovalEcho(envelope, echo, now = new Date()) {
             changed,
         };
 }
-function blockedApprovalResult(params) {
-    return {
-        status: "blocked",
-        blocker: params.blocker,
-        guidance: "The durable refill approval no longer matches its persisted scope; render and approve a new packet before mutation.",
-        report: {
-            changed: params.changed,
-            ...(params.fresh === undefined ? {} : { fresh: params.fresh }),
-        },
-        readOnly: false,
-        forbiddenActions: FORBIDDEN_ACTIONS,
-        boundedAuthority: BOUNDED_AUTHORITY,
-    };
-}
-function storedApprovalFromStatus(value) {
-    const status = record(value) ?? {};
-    const config = record(status.config);
-    const scope = record(config?.scope);
-    const approval = record(config?.approval);
-    const scopeHash = text(config?.scopeHash);
-    if (!config || !scope || !approval || !scopeHash)
-        return null;
-    return {
-        config,
-        scope,
-        scopeHash,
-        approval,
-        hasDispatched: status.hasDispatched === true,
-    };
-}
-function validateStoredApprovalEcho(params) {
-    const fields = [
-        "scopeHash",
-        "targetShapeRevision",
-        "actionFingerprint",
-        "expectedTargetsHash",
-        "approvalExpiresAt",
-        "approvalFingerprint",
-    ];
-    const changed = fields.filter((field) => text(params.approval[field]) !== params.echo[field]);
-    const expiresAt = text(params.approval.approvalExpiresAt);
-    if (!params.allowExpired &&
-        (!expiresAt ||
-            Date.parse(expiresAt) <= (params.now ?? new Date()).getTime())) {
-        return {
-            ok: false,
-            blocker: "approval_expired",
-            changed,
-        };
-    }
-    return changed.length === 0
-        ? { ok: true }
-        : {
-            ok: false,
-            blocker: "approval_fingerprint_mismatch",
-            changed,
-        };
-}
-function executionScopeFromStored(scope, fallback) {
-    const dateSelector = record(scope.dateSelector) ?? {};
-    const kind = text(dateSelector.kind);
-    const senderIds = list(scope.senderIds)
-        .map((value) => text(value))
-        .filter((value) => value != null);
-    const approvalMode = scope.approvalMode === "mark_ready" ? "mark_ready" : "approve";
-    return {
-        intent: text(scope.intent) ?? fallback.intent,
-        senderIds,
-        approvalMode,
-        ...(kind === "target_date" && text(dateSelector.targetDate)
-            ? { targetDate: text(dateSelector.targetDate) }
-            : kind === "until_date" && text(dateSelector.untilDate)
-                ? { untilDate: text(dateSelector.untilDate) }
-                : kind === "horizon_send_days" &&
-                    typeof dateSelector.horizonSendDays === "number"
-                    ? { horizonSendDays: dateSelector.horizonSendDays }
-                    : {}),
-    };
-}
 async function maybeAddLostFenceGuidance(result, input) {
     if (result.status !== "blocked" ||
         result.blocker !== "lease_lost" ||
@@ -448,53 +365,7 @@ export async function refillSendsV2Command(input) {
     let resolvedScope = input.scope;
     let resolvedScopeHash = input.scopeHash;
     let resolvedApproval = input.approval;
-    if (input.runId && input.approvalEcho) {
-        const status = await refillRunStatus({ workspaceId, runId: input.runId });
-        const stored = storedApprovalFromStatus(status);
-        if (!stored) {
-            return {
-                status: "blocked",
-                blocker: "approval_run_unavailable",
-                guidance: "The durable refill run no longer exposes a valid persisted approval packet.",
-                report: { status },
-                readOnly: false,
-                forbiddenActions: FORBIDDEN_ACTIONS,
-                boundedAuthority: BOUNDED_AUTHORITY,
-            };
-        }
-        const validation = validateStoredApprovalEcho({
-            approval: stored.approval,
-            echo: input.approvalEcho,
-            allowExpired: stored.hasDispatched,
-        });
-        if (!validation.ok) {
-            return blockedApprovalResult({
-                blocker: validation.blocker,
-                changed: validation.changed,
-                fresh: stored.approval,
-            });
-        }
-        const freshTargetShapeRevision = input.targetPlan
-            ? (text(input.targetPlan.targetShapeRevision) ??
-                text(record(input.targetPlan.target)?.targetShapeRevision))
-            : null;
-        const storedTargetShapeRevision = text(stored.approval.targetShapeRevision);
-        if (freshTargetShapeRevision &&
-            freshTargetShapeRevision !== storedTargetShapeRevision) {
-            return blockedApprovalResult({
-                blocker: "approval_fingerprint_mismatch",
-                changed: ["targetShapeRevision"],
-                fresh: {
-                    storedTargetShapeRevision,
-                    freshTargetShapeRevision,
-                },
-            });
-        }
-        resolvedScope = stored.scope;
-        resolvedScopeHash = stored.scopeHash;
-        resolvedApproval = stored.approval;
-    }
-    else if (input.targetPlan && input.approvalEcho) {
+    if (input.targetPlan && input.approvalEcho) {
         const envelope = buildApprovalEnvelope({
             workspaceId,
             intent: input.intent,
@@ -508,11 +379,15 @@ export async function refillSendsV2Command(input) {
         });
         const validation = validateApprovalEcho(envelope, input.approvalEcho);
         if (!validation.ok) {
-            return blockedApprovalResult({
+            return {
+                status: "blocked",
                 blocker: validation.blocker,
-                changed: validation.changed,
-                fresh: envelope.approval,
-            });
+                guidance: "The durable refill approval no longer matches fresh scope; render and approve a new packet before mutation.",
+                report: { changed: validation.changed, fresh: envelope.approval },
+                readOnly: false,
+                forbiddenActions: FORBIDDEN_ACTIONS,
+                boundedAuthority: BOUNDED_AUTHORITY,
+            };
         }
         resolvedScope = envelope.scope;
         resolvedScopeHash = envelope.scopeHash;
@@ -534,18 +409,13 @@ export async function refillSendsV2Command(input) {
             boundedAuthority: BOUNDED_AUTHORITY,
         };
     }
-    const executionScope = resolvedScope
-        ? executionScopeFromStored(resolvedScope, input)
-        : {
-            intent: input.intent,
-            senderIds: input.senderIds,
-            approvalMode: input.approvalMode ?? "approve",
-            ...date,
-        };
     const result = await runRefillV2Loop({
         workspaceId,
-        ...executionScope,
+        intent: input.intent,
+        senderIds: input.senderIds,
+        approvalMode: input.approvalMode ?? "approve",
         resume: resumeHandle(input),
+        ...date,
         scope: resolvedScope,
         scopeHash: resolvedScopeHash,
         approval: resolvedApproval,

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

@@ -725,23 +725,6 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
     intent: RefillSendsIntent;
 } | {
     yoloExecution: {
-        selectedAction: Record<string, unknown> | null;
-        targetPlanReread: boolean;
-        status: "blocked";
-        blocker: "approval_expired" | "approval_fingerprint_mismatch";
-        guidance: string;
-        report: {
-            fresh?: {} | null | undefined;
-            changed: string[];
-        };
-        readOnly: boolean;
-        forbiddenActions: string[];
-        boundedAuthority: string;
-        enabled: boolean;
-        result?: undefined;
-        refusalReason?: undefined;
-        postActionFirstAction?: undefined;
-    } | {
         selectedAction: Record<string, unknown> | null;
         targetPlanReread: boolean;
         readOnly: boolean;

package/dist/tools/refill-sends.js

@@ -1,6 +1,6 @@
-import { REFILL_CONTRACT_CACHE_VERSION, REFILL_CONTRACT_HASH, REFILL_CONTRACT_VERSION, renderRefillBootstrapGuidance, renderRefillSafetyGuidance, renderRefillTerminalGuidance, } from "../refill-contract.js";
 import { actionIds, classifyPaidInmailRefreshReceipt, collectPaidInmailRefreshActions, executeOneYoloPrimitive, firstGlobalAction, normalizeStrings, numberValue, recordValue, refreshPaidInmailCreditsWithRetry, stringValue, } from "./refill-executors.js";
 import { prepareRefillSendsV2Approval, refillSendsV2Command, } from "./refill-sends-v2.js";
+import { REFILL_CONTRACT_CACHE_VERSION, REFILL_CONTRACT_HASH, REFILL_CONTRACT_VERSION, renderRefillBootstrapGuidance, renderRefillSafetyGuidance, renderRefillTerminalGuidance, } from "../refill-contract.js";
 import { getRefillTargetPlan } from "./refill-target-plan.js";
 import { createWorkspaceContext, normalizeExplicitWorkspaceId, } from "./workspace-context.js";
 const REFILL_SEND_ACTION_TYPES = ["send_invite", "send_inmail_closed"];
@@ -563,13 +563,8 @@ export async function executeRefillSendsCommand(input = {}) {
     }
     const targetPlanInput = targetPlanInputFor(scopedInput);
     const targetPlanBeforePaidRefresh = await getRefillTargetPlan(targetPlanInput);
-    const durableResumeRequested = Boolean(yolo &&
-        workspaceId &&
-        scopedInput.runId &&
-        typeof scopedInput.fence === "number" &&
-        scopedInput.approvalFingerprint);
     const approvedPacket = approvedPacketComparison(scopedInput, targetPlanBeforePaidRefresh);
-    if (!durableResumeRequested && approvedPacket.changed) {
+    if (approvedPacket.changed) {
         return {
             ...command,
             ok: false,
@@ -600,8 +595,7 @@ export async function executeRefillSendsCommand(input = {}) {
     }
     if (yolo &&
         workspaceId &&
-        (durableResumeRequested ||
-            durableV2PlanEligible(targetPlanBeforePaidRefresh))) {
+        durableV2PlanEligible(targetPlanBeforePaidRefresh)) {
         const base = durableYoloBaseResult({
             command,
             targetPlan: targetPlanBeforePaidRefresh,

package/dist/tools/workspaces.d.ts

@@ -142,15 +142,17 @@ export declare function listWorkspaces(): Promise<{
     workspaces: WorkspaceSummary[];
     workspaceLock: {
         enabled: boolean;
-        workspaceId?: undefined;
-        hiddenWorkspaceCount?: undefined;
+        workspaceId: string;
+        hiddenWorkspaceCount: number;
+        siblingInventoryFetched: boolean;
     };
 } | {
     workspaces: WorkspaceSummary[];
     workspaceLock: {
         enabled: boolean;
-        workspaceId: string;
-        hiddenWorkspaceCount: number;
+        workspaceId?: undefined;
+        hiddenWorkspaceCount?: undefined;
+        siblingInventoryFetched?: undefined;
     };
 }>;
 export declare function getActiveWorkspace(): {

package/dist/tools/workspaces.js

@@ -80,19 +80,21 @@ export const workspaceToolDefinitions = [
 ];
 export async function listWorkspaces() {
     const api = getApi();
-    const { workspaces } = await api.get("/api/v3/workspaces");
     const lockedWorkspaceId = getLockedWorkspaceId();
-    if (!lockedWorkspaceId) {
-        return { workspaces, workspaceLock: { enabled: false } };
+    if (lockedWorkspaceId) {
+        const { workspace } = await api.get(`/api/v3/workspaces/${encodeURIComponent(lockedWorkspaceId)}`);
+        return {
+            workspaces: [workspace],
+            workspaceLock: {
+                enabled: true,
+                workspaceId: lockedWorkspaceId,
+                hiddenWorkspaceCount: 0,
+                siblingInventoryFetched: false,
+            },
+        };
     }
-    return {
-        workspaces: workspaces.filter((ws) => ws.id === lockedWorkspaceId),
-        workspaceLock: {
-            enabled: true,
-            workspaceId: lockedWorkspaceId,
-            hiddenWorkspaceCount: workspaces.filter((ws) => ws.id !== lockedWorkspaceId).length,
-        },
-    };
+    const { workspaces } = await api.get("/api/v3/workspaces");
+    return { workspaces, workspaceLock: { enabled: false } };
 }
 export function getActiveWorkspace() {
     const config = getConfig();

package/package.json

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

package/skills/research/config.json

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