@sellable/mcp 0.1.236 → 0.1.238

package/README.md

@@ -20,7 +20,7 @@ There are three public Sellable entrypoints shared across hosts:
 
 - `sellable:create-campaign`
 - `sellable:interview`
-- `sellable:load-voice`
+- `sellable:create-post`
 
 The create-campaign public wrapper at
 `mcp/sellable/skills/create-campaign/SKILL.md` handles auth/bootstrap and loads
@@ -33,12 +33,15 @@ from:
 
 - `mcp/sellable/skills/interview/SKILL.md`
 
-The load-voice public wrapper loads the current voice/company memory for use in
-writing, application answers, posts, replies, and reviews from:
+The create-post public wrapper captures raw ideas, loads voice internally,
+researches hooks, validates proof/AI tells, and saves content artifacts under
+`~/.sellable/content/linkedin/**` from:
 
-- `mcp/sellable/skills/load-voice/SKILL.md`
+- `mcp/sellable/skills/create-post/SKILL.md`
 
-Keep `create-campaign-v2` internal. Do not advertise it as a public command.
+Keep `create-campaign-v2` and `load-voice` internal. Do not advertise either as
+a public command. `load-voice` remains a direct MCP utility for generic writing
+surfaces that are not posts or campaigns.
 
 ### 1. One-Command Agent Install
 
@@ -134,8 +137,8 @@ The installer does the full local setup:
 
 After the installer passes, fully quit and reopen Codex Desktop. Start a new
 thread and select `Sellable Create Campaign`, `Sellable Identity Interview`, or
-`Sellable Load Voice`; or invoke `$sellable:create-campaign`,
-`$sellable:interview`, or `$sellable:load-voice`. If the app still says
+`Sellable Create Post`; or invoke `$sellable:create-campaign`,
+`$sellable:interview`, or `$sellable:create-post`. If the app still says
 `mcp__sellable__*` tools are missing after the installer passes, check that
 `~/.codex/config.toml` contains both `[marketplaces.sellable]` and
 `[plugins."sellable@sellable"]`.
@@ -148,24 +151,26 @@ Use these names consistently:
 
 - Claude Code command: `/sellable:create-campaign`
 - Claude Code command: `/sellable:interview`
-- Claude Code command: `/sellable:load-voice`
+- Claude Code command: `/sellable:create-post`
 - Codex command: `$sellable:create-campaign`
 - Codex command: `$sellable:interview`
-- Codex command: `$sellable:load-voice`
+- Codex command: `$sellable:create-post`
 - Codex Desktop plugin: `sellable@sellable`
 - Codex visible skill: `Sellable Create Campaign`
 - Codex visible skill: `Sellable Identity Interview`
-- Codex visible skill: `Sellable Load Voice`
+- Codex visible skill: `Sellable Create Post`
 - Codex skill frontmatter name: `create-campaign`
 - Codex skill frontmatter name: `interview`
-- Codex skill frontmatter name: `load-voice`
+- Codex skill frontmatter name: `create-post`
 - MCP server name: `sellable`
 - Internal workflow prompt: `create-campaign-v2`
 
 Never tell users to run `/sellable:create-campaign-v2`,
-`$sellable:create-campaign-v2`, or `$sellable:sellable:create-campaign`.
-`create-campaign-v2` is an internal MCP subskill loaded by
-`get_subskill_prompt({ subskillName: "create-campaign-v2" })`.
+`$sellable:create-campaign-v2`, `$sellable:load-voice`, or
+`$sellable:sellable:create-campaign`. `create-campaign-v2` is an internal MCP
+subskill loaded by `get_subskill_prompt({ subskillName: "create-campaign-v2" })`.
+`load-voice` is an internal direct MCP utility; `create-post` loads voice
+silently for post drafting.
 
 ## Structured Question Parity
 

package/dist/engage-memory.d.ts

@@ -19,6 +19,7 @@ export interface TrackedPerson {
 }
 export interface EngageMemory {
     styleGuide?: EngageStyleGuide;
+    postWritingRules?: EngageStyleGuide;
     provenSearches: ProvenSearch[];
     trackedPeople: TrackedPerson[];
     identity?: IdentityMemoryChunk;

package/dist/engage-memory.js

@@ -116,8 +116,18 @@ function buildMarkdownTable(headers, rows) {
 // ── Style guide ────────────────────────────────────────────────────────────
 const FLAT_STYLE_CORE_PATH = "writing/styleguide-core.md";
 const STYLE_COMMENTS_PATH = "writing/comments.md";
+const STYLE_POSTS_PATH = "writing/posts.md";
 const LEGACY_AUDIENCE_ICP_PATH = "audience/icp.md";
 const LEGACY_FAQS_CORE_PATH = "faqs/core.md";
+function readPostWritingRules() {
+    const markdown = readFile(STYLE_POSTS_PATH);
+    if (!markdown)
+        return undefined;
+    return {
+        markdown,
+        updatedAt: latestUpdatedAt([STYLE_POSTS_PATH]),
+    };
+}
 function readStyleGuide(senderId, identityMemory) {
     const corePath = senderPath(senderId, "styleguide-core.md", FLAT_STYLE_CORE_PATH);
     const core = readFile(corePath);
@@ -200,7 +210,8 @@ function hasCoreIdentityMemory(identityMemory) {
         identityMemory.decisionRules ||
         identityMemory.changeLog ||
         identityMemory.transcripts?.index ||
-        identityMemory.references?.index);
+        identityMemory.references?.index ||
+        (identityMemory.references?.childIndexes?.length ?? 0) > 0);
 }
 function appendCoreSection(parts, sourcePaths, title, chunk) {
     if (!chunk)
@@ -209,9 +220,12 @@ function appendCoreSection(parts, sourcePaths, title, chunk) {
     sourcePaths.push(chunk.source.relativePath);
 }
 function appendCoreDirectoryIndex(parts, sourcePaths, title, directory) {
-    if (!directory?.index)
+    if (!directory)
         return;
     appendCoreSection(parts, sourcePaths, title, directory.index);
+    for (const childIndex of directory.childIndexes ?? []) {
+        appendCoreSection(parts, sourcePaths, title, childIndex);
+    }
 }
 function appendCompatibilitySection(parts, sourcePaths, section) {
     parts.push(`## ${section.title} (${section.relativePath})\n\n${section.markdown.trim()}`);
@@ -229,11 +243,13 @@ function latestUpdatedAt(relativePaths) {
 export function getEngageMemory(senderId) {
     const identityMemory = readIdentityMemory({ connectedSenderId: senderId });
     const styleGuide = readStyleGuide(senderId, identityMemory);
+    const postWritingRules = readPostWritingRules();
     const provenSearches = readProvenSearches(senderId);
     const trackedPeople = readTrackedPeople(senderId);
     return {
         memory: {
             styleGuide,
+            postWritingRules,
             provenSearches,
             trackedPeople,
             ...identityMemory,

package/dist/identity-memory.d.ts

@@ -23,6 +23,7 @@ export interface IdentityMemoryChunk {
 export interface IdentityMemoryDirectory {
     source: IdentityMemorySource;
     index?: IdentityMemoryChunk;
+    childIndexes?: IdentityMemoryChunk[];
 }
 export interface IdentityMemory {
     identity?: IdentityMemoryChunk;

package/dist/identity-memory.js

@@ -81,5 +81,32 @@ function readDirectory(configsDir, relativePath) {
     if (index) {
         directory.index = index;
     }
+    const childIndexes = readChildIndexes(configsDir, relativePath);
+    if (childIndexes.length > 0) {
+        directory.childIndexes = childIndexes;
+    }
     return directory;
 }
+function readChildIndexes(configsDir, relativePath) {
+    const root = path.join(configsDir, relativePath);
+    const indexes = [];
+    function walk(currentFullPath, currentRelativePath) {
+        for (const entry of fs.readdirSync(currentFullPath).sort()) {
+            const entryFullPath = path.join(currentFullPath, entry);
+            const entryRelativePath = `${currentRelativePath}/${entry}`;
+            const stat = fs.statSync(entryFullPath);
+            if (stat.isDirectory()) {
+                walk(entryFullPath, entryRelativePath);
+            }
+            else if (stat.isFile() &&
+                entry === "INDEX.md" &&
+                entryRelativePath !== `${relativePath}/INDEX.md`) {
+                const chunk = readMarkdownChunk(configsDir, entryRelativePath);
+                if (chunk)
+                    indexes.push(chunk);
+            }
+        }
+    }
+    walk(root, relativePath);
+    return indexes;
+}

package/dist/server.js

@@ -10,6 +10,7 @@ import { getCampaignTableSchema, queueCampaignCells, reviseMessageTemplateAndRer
 import { queueCells, updateCell } from "./tools/cells.js";
 import { handleStartCliLogin, handleWaitForCliLogin, } from "./tools/cli-login.js";
 import { getCampaignContext, hydrateCampaignContextFromCampaign, markCampaignContextDirty, } from "./tools/context.js";
+import { capturePostIdeaTool, getPostDraftTool, getPostIdeaTool, listPostDraftsTool, listPostIdeasTool, listPublishedPostsTool, markPostPublishedTool, saveHookResearchTool, savePostDraftTool, } from "./tools/content-posts.js";
 import { addToCommentCampaign, addToConnectionCampaign, addToInmailCampaign, getEngagedPosts, getOrCreateDirectCampaignTable, pauseDirectCampaign, startDirectCampaign, } from "./tools/direct-campaigns.js";
 import { bootstrapEngage, bootstrapEngageMulti, } from "./tools/engage-bootstrap.js";
 import { searchEngagementPosts } from "./tools/engage-discovery.js";
@@ -222,6 +223,33 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "get_campaign_navigation_state":
                 result = await getCampaignNavigationState(args);
                 break;
+            case "capture_post_idea":
+                result = capturePostIdeaTool(args);
+                break;
+            case "list_post_ideas":
+                result = listPostIdeasTool(args);
+                break;
+            case "get_post_idea":
+                result = getPostIdeaTool(args);
+                break;
+            case "save_hook_research":
+                result = saveHookResearchTool(args);
+                break;
+            case "save_post_draft":
+                result = savePostDraftTool(args);
+                break;
+            case "list_post_drafts":
+                result = listPostDraftsTool(args);
+                break;
+            case "get_post_draft":
+                result = getPostDraftTool(args);
+                break;
+            case "mark_post_published":
+                result = markPostPublishedTool(args);
+                break;
+            case "list_published_posts":
+                result = listPublishedPostsTool(args);
+                break;
             case "get_table_rows":
                 result = await getTableRows(args?.tableId, {
                     limit: args?.limit,

package/dist/tools/campaigns.js

@@ -49,24 +49,27 @@ function getCampaignBuilderWatchModeFromUrl(watchUrl) {
 export function getCampaignBuilderWatchModeDriverLabel(mode = getCampaignBuilderWatchModeParam()) {
     return mode === "codex" ? "Codex" : "Claude Code";
 }
-function centerWatchHandoffHeadline(headline) {
-    const width = 60;
+function buildWatchHandoffHeadlineBox(headline) {
+    const width = 52;
     const visibleHeadline = headline.length > width ? headline.slice(0, width) : headline;
     const padding = Math.max(width - visibleHeadline.length, 0);
     const left = Math.floor(padding / 2);
     const right = padding - left;
+    const border = `+${"-".repeat(width + 2)}+`;
     return [
-        `╔${"═".repeat(width + 2)}╗`,
-        `║ ${" ".repeat(left)}${visibleHeadline}${" ".repeat(right)} ║`,
-        `╚${"═".repeat(width + 2)}╝`,
+        "```text",
+        border,
+        `| ${" ".repeat(left)}${visibleHeadline}${" ".repeat(right)} |`,
+        border,
+        "```",
     ].join("\n");
 }
 export function buildCampaignWatchHandoffMarkdown(watchUrl, mode = getCampaignBuilderWatchModeFromUrl(watchUrl) ??
     getCampaignBuilderWatchModeParam()) {
     const driverLabel = getCampaignBuilderWatchModeDriverLabel(mode);
-    const headline = `OPEN THIS LINK TO WATCH ${driverLabel.toUpperCase()} BUILD THE CAMPAIGN LIVE`;
+    const headline = `WATCH ${driverLabel.toUpperCase()} BUILD THE CAMPAIGN LIVE`;
     return [
-        centerWatchHandoffHeadline(headline),
+        buildWatchHandoffHeadlineBox(headline),
         "",
         `[Open live campaign builder](${watchUrl})`,
         "",

package/dist/tools/content-posts.d.ts

@@ -0,0 +1,308 @@
+type ContentKind = "idea" | "hook_research" | "draft" | "published_post";
+type ArtifactMetadata = {
+    id: string;
+    type: ContentKind;
+    status: string;
+    createdAt: string;
+    updatedAt: string;
+    title?: string;
+    ideaId?: string;
+    hookResearchId?: string;
+    publishUrl?: string;
+    publishedAt?: string;
+    sourceType?: string;
+    sourceUrl?: string;
+    [key: string]: unknown;
+};
+export type ContentPostSummary = {
+    id: string;
+    type: ContentKind;
+    status: string;
+    path: string;
+    title?: string;
+    updatedAt: string;
+    preview: string;
+};
+export declare const contentPostToolDefinitions: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            rawSource: {
+                type: string;
+                description: string;
+            };
+            title: {
+                type: string;
+            };
+            distilledBrief: {
+                type: string;
+                description: string;
+            };
+            ideaId: {
+                type: string;
+                description: string;
+            };
+            sourceType: {
+                type: string;
+            };
+            sourceUrl: {
+                type: string;
+            };
+            capturedAt: {
+                type: string;
+            };
+            researchId?: undefined;
+            topic?: undefined;
+            keywords?: undefined;
+            sourcePosts?: undefined;
+            selectedPatterns?: undefined;
+            notes?: undefined;
+            createdAt?: undefined;
+            draftId?: undefined;
+            hookResearchId?: undefined;
+            body?: undefined;
+            validationReceipt?: undefined;
+            status?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            limit: {
+                type: string;
+            };
+        };
+        required: never[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            [x: string]: {
+                type: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            researchId: {
+                type: string;
+            };
+            ideaId: {
+                type: string;
+                description?: undefined;
+            };
+            topic: {
+                type: string;
+            };
+            keywords: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+            sourcePosts: {
+                type: string;
+                items: {
+                    type: string;
+                    additionalProperties: boolean;
+                };
+            };
+            selectedPatterns: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+            notes: {
+                type: string;
+            };
+            createdAt: {
+                type: string;
+            };
+            rawSource?: undefined;
+            title?: undefined;
+            distilledBrief?: undefined;
+            sourceType?: undefined;
+            sourceUrl?: undefined;
+            capturedAt?: undefined;
+            draftId?: undefined;
+            hookResearchId?: undefined;
+            body?: undefined;
+            validationReceipt?: undefined;
+            status?: undefined;
+        };
+        required: never[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            draftId: {
+                type: string;
+            };
+            ideaId: {
+                type: string;
+                description?: undefined;
+            };
+            hookResearchId: {
+                type: string;
+            };
+            title: {
+                type: string;
+            };
+            body: {
+                type: string;
+            };
+            validationReceipt: {
+                description: string;
+            };
+            createdAt: {
+                type: string;
+            };
+            status: {
+                type: string;
+            };
+            rawSource?: undefined;
+            distilledBrief?: undefined;
+            sourceType?: undefined;
+            sourceUrl?: undefined;
+            capturedAt?: undefined;
+            researchId?: undefined;
+            topic?: undefined;
+            keywords?: undefined;
+            sourcePosts?: undefined;
+            selectedPatterns?: undefined;
+            notes?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+})[];
+export declare function resolveContentRoot(): string;
+export declare function ensureContentLayout(root?: string): {
+    root: string;
+    directories: {
+        ideas: "linkedin/ideas";
+        hookResearch: "linkedin/research/hooks";
+        drafts: "linkedin/drafts";
+        published: "linkedin/published";
+        commentLibrary: "linkedin/comments/library";
+    };
+};
+export declare function capturePostIdeaTool(input: {
+    rawSource: string;
+    title?: string;
+    distilledBrief?: string;
+    ideaId?: string;
+    sourceType?: string;
+    sourceUrl?: string;
+    capturedAt?: string;
+}): {
+    id: string;
+    path: string;
+    status: string;
+    createdAt: string;
+    updatedAt: string;
+    preview: string;
+    rawSourceExact: boolean;
+};
+export declare function listPostIdeasTool(input?: {
+    limit?: number;
+}): ContentPostSummary[];
+export declare function getPostIdeaTool(input: {
+    ideaId: string;
+}): {
+    id: string;
+    path: string;
+    metadata: ArtifactMetadata;
+    markdown: string;
+    rawSource: string | undefined;
+};
+export declare function saveHookResearchTool(input: {
+    researchId?: string;
+    ideaId?: string;
+    topic?: string;
+    keywords?: string[];
+    sourcePosts?: Array<Record<string, unknown>>;
+    selectedPatterns?: string[];
+    notes?: string;
+    createdAt?: string;
+}): {
+    id: string;
+    path: string;
+    status: string;
+    ideaId: string | undefined;
+    updatedAt: string;
+    preview: string;
+};
+export declare function savePostDraftTool(input: {
+    draftId?: string;
+    ideaId: string;
+    hookResearchId?: string;
+    title?: string;
+    body: string;
+    validationReceipt: unknown;
+    createdAt?: string;
+    status?: string;
+}): {
+    id: string;
+    path: string;
+    status: string;
+    ideaId: string;
+    hookResearchId: string | undefined;
+    updatedAt: string;
+    preview: string;
+};
+export declare function listPostDraftsTool(input?: {
+    limit?: number;
+}): ContentPostSummary[];
+export declare function getPostDraftTool(input: {
+    draftId: string;
+}): {
+    id: string;
+    path: string;
+    metadata: ArtifactMetadata;
+    markdown: string;
+    rawSource: string | undefined;
+};
+export declare function markPostPublishedTool(input: {
+    draftId?: string;
+    publishUrl: string;
+    activityId?: string;
+    publishedAt?: string;
+    finalText?: string;
+    title?: string;
+}): {
+    id: string;
+    path: string;
+    status: string;
+    draftId: string | undefined;
+    publishUrl: string;
+    publishedAt: string;
+    updatedAt: string;
+    preview: string;
+};
+export declare function listPublishedPostsTool(input?: {
+    limit?: number;
+}): ContentPostSummary[];
+export {};