@sellable/install 0.1.212 → 0.1.214

package/README.md

@@ -31,9 +31,9 @@ agent command for launching a campaign:
 sellable create
 ```
 
-Campaign creation, foundation memory, content capture/ideation, and post
-drafting run inside Claude Code or Codex, where the Sellable MCP tools and
-approval flows are available.
+Campaign creation, foundation memory, content capture/ideation, post drafting,
+and inbox reply management run inside Claude Code or Codex, where the Sellable
+MCP tools and approval flows are available.
 
 Install is auth-free by default. If you do not pass a token, the agent handles
 Sellable sign-in on the first campaign run with a magic-link handoff.
@@ -97,17 +97,20 @@ Use the same public entrypoints in both hosts:
 - Claude Code: `/sellable:foundation`
 - Claude Code: `/sellable:content`
 - Claude Code: `/sellable:create-post`
+- Claude Code: `/sellable:inbox`
 - Codex: `$sellable:create-campaign`
 - Codex: `$sellable:create-ab-test`
 - Codex: `$sellable:foundation`
 - Codex: `$sellable:content`
 - Codex: `$sellable:create-post`
+- Codex: `$sellable:inbox`
 - Codex Desktop plugin: `sellable@sellable`
 - Codex visible skill: `Sellable Create Campaign`
 - Codex visible skill: `Sellable Create A/B Test`
 - Codex visible skill: `Sellable Foundation`
 - Codex visible skill: `Sellable Content`
 - Codex visible skill: `Sellable Create Post`
+- Codex visible skill: `Sellable Inbox`
 - Internal MCP workflow prompt: `create-campaign-v2`
 - Internal/backward-compatible memory prompt: `interview`
 

package/bin/sellable-install.mjs

@@ -182,7 +182,7 @@ Options:
 
 Auth:
   Install is auth-free by default. Sign in happens on the first run of
-  /sellable:create-campaign, /sellable:foundation, /sellable:content, or /sellable:create-post in Claude Code or Codex,
+  /sellable:create-campaign, /sellable:foundation, /sellable:content, /sellable:create-post, or /sellable:inbox in Claude Code or Codex,
   where the agent walks you through signup or sign-in and stores credentials
   in ~/.sellable/config.json.
 
@@ -211,6 +211,7 @@ function printCreateCommandHint() {
     { label: "Foundation", command: "/sellable:foundation" },
     { label: "Content", command: "/sellable:content" },
     { label: "Post", command: "/sellable:create-post" },
+    { label: "Inbox", command: "/sellable:inbox" },
   ]);
   console.log("");
   console.log("");
@@ -220,6 +221,7 @@ function printCreateCommandHint() {
     { label: "Foundation", command: "$sellable:foundation" },
     { label: "Content", command: "$sellable:content" },
     { label: "Post", command: "$sellable:create-post" },
+    { label: "Inbox", command: "$sellable:inbox" },
   ]);
   console.log("");
   console.log(`   ${"─".repeat(63)}`);
@@ -330,10 +332,6 @@ function isWindowsPlatform(platform = process.platform) {
   return platform === "win32";
 }
 
-function packageRunnerCommand(platform = process.platform) {
-  return isWindowsPlatform(platform) ? "npx.cmd" : "npx";
-}
-
 function packageManagerCommand(platform = process.platform) {
   return isWindowsPlatform(platform) ? "npm.cmd" : "npm";
 }
@@ -551,6 +549,14 @@ function upsertTomlTable(content, tableName, block) {
   return `${content.trimEnd()}\n\n${normalizedBlock}\n`;
 }
 
+function readTomlTable(content, tableName) {
+  const tablePattern = new RegExp(
+    `(^|\\n)\\[${escapeRegExp(tableName)}\\]\\n([\\s\\S]*?)(?=\\n\\[[^\\n]+\\]|$)`
+  );
+  const match = content.match(tablePattern);
+  return match ? match[2] : "";
+}
+
 function upsertTomlBoolean(content, tableName, key, value) {
   const line = `${key} = ${value ? "true" : "false"}`;
   const tablePattern = new RegExp(
@@ -678,12 +684,13 @@ function codexPluginMcp(opts) {
     };
   }
 
+  const [command, args] = mcpCommand(opts);
   return {
     mcpServers: {
       sellable: {
         type: "stdio",
-        command: packageRunnerCommand(),
-        args: ["-y", opts.mcpPackage],
+        command,
+        args,
         env: {
           SELLABLE_WATCH_MODE_DRIVER: "codex",
         },
@@ -1748,6 +1755,67 @@ then retry \`get_subskill_prompt\`.
 `, host, "create-post");
 }
 
+function inboxSkillMd(host = "shared") {
+  return stampInstalledHost(`---
+name: inbox
+description: Search Sellable inbox threads, review reply eligibility, and manage approval-gated LinkedIn replies.
+allowed-tools:
+  - mcp__sellable__get_auth_status
+  - mcp__sellable__search_inbox_threads
+  - mcp__sellable__get_inbox_thread
+  - mcp__sellable__check_inbox_reply_eligibility
+  - mcp__sellable__update_inbox_draft
+  - mcp__sellable__send_inbox_draft
+  - mcp__sellable__send_inbox_manual_reply
+---
+
+# Sellable Inbox
+
+Use this as the customer-facing entrypoint for Sellable inbox reply management.
+It can search LinkedIn inbox threads, load thread history, check product reply
+eligibility, update an existing draft, send an approved draft, or send one exact
+manual reply.
+
+## Bootstrap
+
+MCP tool access is required. First call \`mcp__sellable__get_auth_status({})\`.
+Do not inspect repo files, run shell commands, use \`npm\`, \`node\`, local
+harness scripts, browser automation, or product API routes to emulate this
+workflow.
+
+If the Sellable MCP tool is unavailable, stop and say this is a Codex
+install/reload problem. Tell the user to run
+\`curl -fsSL "https://app.sellable.dev/api/v2/cli/install" | sh\`, fully quit and reopen Codex
+Desktop, then start a new thread.
+
+## Read Workflow
+
+1. Call \`mcp__sellable__get_auth_status({})\`.
+2. Use \`mcp__sellable__search_inbox_threads({ limit, search?, filter?, status?, senderId?, classification?, includeReplyEligibility? })\` to find candidate threads.
+3. Use \`mcp__sellable__get_inbox_thread({ threadId })\` before summarizing or drafting.
+4. Use \`mcp__sellable__check_inbox_reply_eligibility({ threadId })\` before proposing any reply send path.
+
+## Approval Gates
+
+Never call \`mcp__sellable__update_inbox_draft\`,
+\`mcp__sellable__send_inbox_draft\`, or
+\`mcp__sellable__send_inbox_manual_reply\` until the user has explicitly
+approved all of:
+
+- workspace/account context
+- sender
+- thread or recipient
+- exact body
+- exact tool to call
+- expected side effect
+
+Draft edits only edit an existing draft. They do not create a new reply draft.
+Send tools support one thread at a time; do not batch sends. If any approval,
+snapshot, hash, version, eligibility, or idempotency value is missing or stale,
+stop and re-read the thread instead of guessing.
+`, host, "inbox");
+}
+
 function createCampaignSoulMd() {
   return `# Sellable Campaign GTM Engineer Soul
 
@@ -1969,6 +2037,12 @@ function codexPluginSkills() {
       description: "Capture ideas and draft LinkedIn posts in your voice",
       skillMd: createPostSkillMd(),
     },
+    {
+      dir: "sellable-inbox",
+      displayName: "Sellable Inbox",
+      description: "Search and manage approval-gated LinkedIn inbox replies",
+      skillMd: inboxSkillMd(),
+    },
   ];
 }
 
@@ -2194,6 +2268,23 @@ function claudeCommands() {
       argumentHint: "[post idea or source material]",
       skillMd: createPostSkillMd(),
     },
+    {
+      name: "inbox",
+      title: "Inbox",
+      filename: join("sellable", "inbox.md"),
+      description: "Search and manage approval-gated Sellable inbox replies.",
+      argumentHint: "[thread, sender, recipient, or reply goal]",
+      skillMd: inboxSkillMd(),
+      allowedTools: [
+        "mcp__sellable__get_auth_status",
+        "mcp__sellable__search_inbox_threads",
+        "mcp__sellable__get_inbox_thread",
+        "mcp__sellable__check_inbox_reply_eligibility",
+        "mcp__sellable__update_inbox_draft",
+        "mcp__sellable__send_inbox_draft",
+        "mcp__sellable__send_inbox_manual_reply",
+      ],
+    },
   ].map((command) => ({
     ...command,
     content: claudeCommandMd(command),
@@ -2386,6 +2477,7 @@ enabled = false`
       "default_mode_request_user_input",
       true
     );
+    content = upsertCodexMcpServerConfig(content, opts);
     content = upsertTomlTable(
       content,
       "agents",
@@ -2544,6 +2636,68 @@ function codexMcpAddArgs(opts) {
   ];
 }
 
+function upsertCodexMcpServerConfig(content, opts) {
+  if (opts.server === "hosted") {
+    content = upsertTomlTable(
+      content,
+      "mcp_servers.sellable",
+      `[mcp_servers.sellable]
+url = ${quoteToml(withHostedWatchModeDriver(opts.hostedUrl, "codex"))}`
+    );
+    content = removeTomlSection(content, "mcp_servers.sellable.env");
+    return content;
+  }
+
+  const [command, args] = mcpCommand(opts);
+  content = upsertTomlTable(
+    content,
+    "mcp_servers.sellable",
+    `[mcp_servers.sellable]
+command = ${quoteToml(command)}
+args = ${tomlArray(args)}`
+  );
+  content = upsertTomlTable(
+    content,
+    "mcp_servers.sellable.env",
+    `[mcp_servers.sellable.env]
+SELLABLE_WATCH_MODE_DRIVER = "codex"`
+  );
+  return content;
+}
+
+function codexMcpServerMatches(content, opts) {
+  const server = readTomlTable(content, "mcp_servers.sellable");
+  if (!server) return false;
+  if (opts.server === "hosted") {
+    return (
+      server.includes(
+        `url = ${quoteToml(withHostedWatchModeDriver(opts.hostedUrl, "codex"))}`
+      ) &&
+      !/\bcommand\s*=/.test(server) &&
+      !/\bargs\s*=/.test(server)
+    );
+  }
+
+  const [command, args] = mcpCommand(opts);
+  const env = readTomlTable(content, "mcp_servers.sellable.env");
+  return (
+    server.includes(`command = ${quoteToml(command)}`) &&
+    server.includes(`args = ${tomlArray(args)}`) &&
+    env.includes('SELLABLE_WATCH_MODE_DRIVER = "codex"')
+  );
+}
+
+function codexPluginMcpServerMatches(content, opts) {
+  if (!content) return false;
+  try {
+    const actual = JSON.parse(content)?.mcpServers?.sellable;
+    const expected = codexPluginMcp(opts).mcpServers.sellable;
+    return JSON.stringify(actual) === JSON.stringify(expected);
+  } catch {
+    return false;
+  }
+}
+
 function installClaude(opts) {
   if (!commandExists("claude")) {
     const message =
@@ -3027,6 +3181,30 @@ async function verify(opts) {
           : "Codex Desktop plugin watch mode driver missing"
       )
     );
+    const codexMcpEntriesCanonical = codexMcpServerMatches(
+      configContent,
+      opts
+    );
+    checks.push(
+      warningCheck(
+        codexMcpEntriesCanonical,
+        codexMcpEntriesCanonical
+          ? "Codex CLI Sellable MCP entry canonical"
+          : "Codex CLI Sellable MCP entry stale"
+      )
+    );
+    const codexPluginMcpEntryCanonical = codexPluginMcpServerMatches(
+      pluginMcpContent,
+      opts
+    );
+    checks.push(
+      warningCheck(
+        codexPluginMcpEntryCanonical,
+        codexPluginMcpEntryCanonical
+          ? "Codex Desktop plugin Sellable MCP entry canonical"
+          : "Codex Desktop plugin Sellable MCP entry stale"
+      )
+    );
     const hasCodexAgentRegistrations = codexCustomAgents().every((agent) =>
       configContent.includes(`[agents.${agent.name}]`)
     );
@@ -3330,6 +3508,7 @@ function printNextSteps(installedHosts, authReused) {
       { label: "Foundation", command: "/sellable:foundation" },
       { label: "Content", command: "/sellable:content" },
       { label: "Post", command: "/sellable:create-post" },
+      { label: "Inbox", command: "/sellable:inbox" },
     ]);
     console.log("");
     console.log("");
@@ -3340,6 +3519,7 @@ function printNextSteps(installedHosts, authReused) {
       { label: "Foundation", command: "$sellable:foundation" },
       { label: "Content", command: "$sellable:content" },
       { label: "Post", command: "$sellable:create-post" },
+      { label: "Inbox", command: "$sellable:inbox" },
     ]);
     console.log("");
   }
@@ -3614,14 +3794,16 @@ async function main() {
       console.log(`  apiUrl: ${apiUrl}`);
       console.log(`  Continue in your agent:`);
       console.log(`    Claude Code: /sellable:create-campaign`);
-      console.log(`    Claude Code: /sellable:foundation`);
-      console.log(`    Claude Code: /sellable:content`);
-      console.log(`    Claude Code: /sellable:create-post`);
-      console.log(`    Codex: $sellable:create-campaign`);
-      console.log(`    Codex: $sellable:foundation`);
-      console.log(`    Codex: $sellable:content`);
-      console.log(`    Codex: $sellable:create-post`);
-      process.exit(0);
+       console.log(`    Claude Code: /sellable:foundation`);
+       console.log(`    Claude Code: /sellable:content`);
+       console.log(`    Claude Code: /sellable:create-post`);
+       console.log(`    Claude Code: /sellable:inbox`);
+       console.log(`    Codex: $sellable:create-campaign`);
+       console.log(`    Codex: $sellable:foundation`);
+       console.log(`    Codex: $sellable:content`);
+       console.log(`    Codex: $sellable:create-post`);
+       console.log(`    Codex: $sellable:inbox`);
+       process.exit(0);
     }
     if (rawArgs[0] === "prefs") {
       const dryRun = rawArgs.includes("--dry-run");

package/lib/runtime-verify.mjs

@@ -3,6 +3,8 @@ import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
 
 const MAX_STDERR_LINES = 80;
 const DEFAULT_VERIFY_TIMEOUT_MS = 10_000;
+const DEFAULT_VERIFY_ATTEMPTS = 2;
+const DEFAULT_VERIFY_RETRY_DELAY_MS = 750;
 
 export const REQUIRED_SELLABLE_MCP_TOOLS = [
   "get_auth_status",
@@ -125,6 +127,15 @@ export function missingRequiredTools(tools, requiredTools) {
   return requiredTools.filter((name) => !available.has(name));
 }
 
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function numberFromEnv(name, fallback) {
+  const parsed = Number(process.env[name] || "");
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
 function textFromToolResult(result) {
   return (result?.content || [])
     .filter((part) => part?.type === "text" && typeof part.text === "string")
@@ -291,7 +302,39 @@ async function verifyCreateCampaignSmoke({
   };
 }
 
-export async function verifySellableMcpRuntime({
+function summarizeAttempt(result, attempt) {
+  return {
+    attempt,
+    ok: result.ok === true,
+    availableToolCount: result.availableTools?.length || 0,
+    missingToolCount: result.missingTools?.length || 0,
+    error: result.error || null,
+    createCampaignSmoke: result.createCampaignSmoke
+      ? {
+          ok: result.createCampaignSmoke.ok === true,
+          error: result.createCampaignSmoke.error || null,
+          missingTools: result.createCampaignSmoke.missingTools || [],
+          calls: (result.createCampaignSmoke.calls || []).map((call) => ({
+            name: call.name,
+            ok: call.ok === true,
+          })),
+        }
+      : null,
+    stderrTail: result.stderrTail || [],
+    startedAt: result.startedAt,
+    completedAt: result.completedAt,
+  };
+}
+
+function shouldRetryRuntimeVerification(result, requiredTools) {
+  if (result.ok || result.skipped) return false;
+  if (result.error) return true;
+  const availableToolCount = result.availableTools?.length || 0;
+  const missingToolCount = result.missingTools?.length || 0;
+  return availableToolCount === 0 || missingToolCount === requiredTools.length;
+}
+
+async function verifySellableMcpRuntimeOnce({
   command,
   args = [],
   cwd = process.cwd(),
@@ -389,3 +432,51 @@ export async function verifySellableMcpRuntime({
     completedAt: new Date().toISOString(),
   };
 }
+
+export async function verifySellableMcpRuntime({
+  command,
+  args = [],
+  cwd = process.cwd(),
+  env = process.env,
+  requiredTools = REQUIRED_SELLABLE_MCP_TOOLS,
+  timeoutMs = Number(process.env.SELLABLE_VERIFY_TIMEOUT_MS || "") ||
+    DEFAULT_VERIFY_TIMEOUT_MS,
+  attempts = numberFromEnv("SELLABLE_VERIFY_ATTEMPTS", DEFAULT_VERIFY_ATTEMPTS),
+  retryDelayMs = numberFromEnv(
+    "SELLABLE_VERIFY_RETRY_DELAY_MS",
+    DEFAULT_VERIFY_RETRY_DELAY_MS
+  ),
+}) {
+  const attemptSummaries = [];
+  let lastResult = null;
+
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const result = await verifySellableMcpRuntimeOnce({
+      command,
+      args,
+      cwd,
+      env,
+      requiredTools,
+      timeoutMs,
+    });
+    lastResult = result;
+    attemptSummaries.push(summarizeAttempt(result, attempt));
+
+    if (
+      attempt >= attempts ||
+      !shouldRetryRuntimeVerification(result, requiredTools)
+    ) {
+      return {
+        ...result,
+        attempts: attemptSummaries,
+      };
+    }
+
+    await sleep(retryDelayMs);
+  }
+
+  return {
+    ...lastResult,
+    attempts: attemptSummaries,
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/install",
-  "version": "0.1.212",
+  "version": "0.1.214",
   "type": "module",
   "description": "One-command installer for Sellable MCP in Claude Code and Codex",
   "bin": {

package/skill-templates/create-campaign.md

@@ -80,6 +80,14 @@ It bootstraps auth and host capabilities, then loads the internal
 the internal campaign workflow prompt and `core/flow.v2.json` through MCP. Keep
 this wrapper thin; the packaged workflow is the operational source of truth.
 
+## Inbox Reply Tool Boundary
+
+Inbox reply tools are outside campaign creation. If a user asks to search,
+review, edit, or send inbox replies, treat that as a separate inbox workflow
+using the existing product /api/v3/inbox routes. Any draft edit or send requires
+exact approval for the workspace, sender, thread, body, tool, and expected side
+effect before the write tool is called.
+
 CampaignOffer state and the watch link are the customer-facing source of truth.
 Disk artifacts are optional debug/UAT diagnostics; normal customer runs should
 not create, link, or surface local draft files unless the user explicitly asks