@sellable/install 0.1.207 → 0.1.209

package/README.md

@@ -55,11 +55,13 @@ Agents should use the agent-readable handoff instead of guessing commands:
 Install Sellable CLI and skills using https://app.sellable.dev/agent-install.txt
 ```
 
-The direct npm installer remains available as a troubleshooting fallback when
-Node/npm/npx are already known-good:
+The direct npm installer is only a package-level troubleshooting fallback for
+maintainers. Public installs should keep using the curl endpoint above because
+it bootstraps Node, repairs legacy state, installs skills, and runs runtime
+verification in one path:
 
 ```bash
-npx -y @sellable/install@latest --host all
+curl -fsSL "https://app.sellable.dev/api/v2/cli/install" | sh
 ```
 
 For CI/scripted installs, get a Sellable API token from:

package/bin/sellable-install.mjs

@@ -136,13 +136,22 @@ function usage() {
   return `Sellable agent installer
 
 Usage:
+  curl -fsSL "https://app.sellable.dev/api/v2/cli/install" | sh
   sellable create
+  sellable prefs set prompt-sharing true|false
+  sellable setup claude-permissions --allow-common-setup
   sellable-install [options]
+
+Advanced fallback:
   npx -y @sellable/install@latest -- [options]
 
 Commands:
   create                   Show how to launch public Sellable workflows.
   auth set <token>         Save a Sellable API token for first-run auth.
+  prefs set prompt-sharing true|false
+                           Save the ask-first prompt-sharing preference.
+  setup claude-permissions --allow-common-setup
+                           Add common Sellable Bash permissions to Claude settings.
   uninstall                Remove Sellable host config and installed artifacts.
 
 Options:
@@ -427,6 +436,83 @@ function readExisting(path) {
   }
 }
 
+function sellableHostEnvPath() {
+  return join(homedir(), ".local", "sellable", "app-sellable-dev", ".env");
+}
+
+function writePromptSharingPreference(value, opts = { dryRun: false }) {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (normalized !== "true" && normalized !== "false") {
+    throw new Error("prompt-sharing must be true or false");
+  }
+  const envPath = sellableHostEnvPath();
+  const key = "SELLABLE_SHARE_SESSION_USER_PROMPTS";
+  const line = `${key}=${normalized}`;
+  const existing = existsSync(envPath) ? readFileSync(envPath, "utf8") : "";
+  const lines = existing
+    .split(/\r?\n/)
+    .filter((existingLine) => existingLine.trim() !== "");
+  let replaced = false;
+  const nextLines = lines.map((existingLine) => {
+    if (existingLine.startsWith(`${key}=`)) {
+      replaced = true;
+      return line;
+    }
+    return existingLine;
+  });
+  if (!replaced) nextLines.push(line);
+
+  if (!opts.dryRun) {
+    mkdirSync(dirname(envPath), { recursive: true, mode: 0o700 });
+    writeFileSync(envPath, `${nextLines.join("\n")}\n`, { mode: 0o600 });
+  }
+  return envPath;
+}
+
+const CLAUDE_COMMON_SETUP_ALLOW = [
+  "Bash(sellable *)",
+  "Bash(export PATH=$HOME/.local/bin:$PATH && sellable *)",
+];
+
+function claudeSettingsPath() {
+  return join(homedir(), ".claude", "settings.json");
+}
+
+function allowClaudeCommonSetup(opts = { dryRun: false }) {
+  const settingsPath = claudeSettingsPath();
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+    } catch (err) {
+      throw new Error(
+        `Could not parse ${settingsPath}: ${
+          err instanceof Error ? err.message : String(err)
+        }`
+      );
+    }
+  }
+  if (!settings || typeof settings !== "object" || Array.isArray(settings)) {
+    settings = {};
+  }
+  const permissions =
+    settings.permissions &&
+    typeof settings.permissions === "object" &&
+    !Array.isArray(settings.permissions)
+      ? settings.permissions
+      : {};
+  const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
+  const nextAllow = [...allow];
+  for (const entry of CLAUDE_COMMON_SETUP_ALLOW) {
+    if (!nextAllow.includes(entry)) nextAllow.push(entry);
+  }
+  settings.permissions = { ...permissions, allow: nextAllow };
+  if (!opts.dryRun) {
+    writeJson(settingsPath, settings, opts);
+  }
+  return settingsPath;
+}
+
 function codexHome() {
   return process.env.CODEX_HOME?.trim() || join(homedir(), ".codex");
 }
@@ -1315,7 +1401,7 @@ local harness scripts, or read local prompt files 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
-\`npx -y ${INSTALL_PACKAGE_SPEC} --host all\`, fully quit and reopen Codex
+\`curl -fsSL "https://app.sellable.dev/api/v2/cli/install" | sh\`, fully quit and reopen Codex
 Desktop, then start a new thread.
 
 1. Call \`mcp__sellable__get_auth_status({})\`.
@@ -1363,7 +1449,7 @@ emulate this workflow.
 
 If the Sellable MCP prompt tools are unavailable, stop and say this is a Codex
 install/reload problem. Tell the user to run
-\`npx -y ${INSTALL_PACKAGE_SPEC} --host all\`, fully quit and reopen Codex
+\`curl -fsSL "https://app.sellable.dev/api/v2/cli/install" | sh\`, fully quit and reopen Codex
 Desktop, then start a new thread.
 
 ## Execute Workflow
@@ -1440,7 +1526,7 @@ emulate this workflow.
 
 If the Sellable MCP prompt tools are unavailable, stop and say this is a Codex
 install/reload problem. Tell the user to run
-\`npx -y ${INSTALL_PACKAGE_SPEC} --host all\`, fully quit and reopen Codex
+\`curl -fsSL "https://app.sellable.dev/api/v2/cli/install" | sh\`, fully quit and reopen Codex
 Desktop, then start a new thread.
 
 ## Execute Workflow
@@ -1512,7 +1598,7 @@ emulate this workflow.
 
 If the Sellable MCP prompt tools are unavailable, stop and say this is a Codex
 install/reload problem. Tell the user to run
-\`npx -y ${INSTALL_PACKAGE_SPEC} --host all\`, fully quit and reopen Codex
+\`curl -fsSL "https://app.sellable.dev/api/v2/cli/install" | sh\`, fully quit and reopen Codex
 Desktop, then start a new thread.
 
 ## Execute Workflow
@@ -1868,12 +1954,7 @@ function legacyClaudeCustomAgents() {
 }
 
 function legacyClaudeCommands() {
-  return [
-    {
-      name: "sellable-create-campaign",
-      filename: join("sellable", "create-campaign.md"),
-    },
-  ];
+  return [];
 }
 
 function tomlArray(values) {
@@ -1930,6 +2011,72 @@ function claudeCustomAgents() {
   }));
 }
 
+function stripFrontmatter(markdown) {
+  return String(markdown).replace(/^---\n[\s\S]*?\n---\n?/, "").trimStart();
+}
+
+function claudeCommandMd(command) {
+  const allowedTools =
+    command.allowedTools && command.allowedTools.length > 0
+      ? `allowed-tools:\n${allowedToolsYaml(command.allowedTools)}\n`
+      : "";
+  return `---
+name: sellable:${command.name}
+description: ${yamlString(command.description)}
+argument-hint: ${yamlString(command.argumentHint || "[instructions]")}
+${allowedTools}---
+
+# Sellable ${command.title}
+
+This Claude Code command is the customer-facing entrypoint for
+\`/sellable:${command.name}\`.
+
+${stripFrontmatter(command.skillMd)}
+`;
+}
+
+function claudeCommands() {
+  return [
+    {
+      name: "create-campaign",
+      title: "Create Campaign",
+      filename: join("sellable", "create-campaign.md"),
+      description: "Create a Sellable campaign through the approval-gated workflow.",
+      argumentHint: "[campaign goal, company, or offer]",
+      skillMd: createCampaignSkillMd(),
+      allowedTools: ["AskUserQuestion", "Task", ...CREATE_CAMPAIGN_ALLOWED_TOOLS],
+    },
+    {
+      name: "foundation",
+      title: "Foundation",
+      filename: join("sellable", "foundation.md"),
+      description: FOUNDATION_SKILL_DESCRIPTION,
+      argumentHint: "[founder/company context]",
+      skillMd: foundationSkillMd(),
+    },
+    {
+      name: "content",
+      title: "Content",
+      filename: join("sellable", "content.md"),
+      description:
+        "Add transcripts and rough ideas, cluster themes, and hand post requests to create-post.",
+      argumentHint: "[idea, transcript, or content goal]",
+      skillMd: contentSkillMd(),
+    },
+    {
+      name: "create-post",
+      title: "Create Post",
+      filename: join("sellable", "create-post.md"),
+      description: "Capture ideas and draft LinkedIn posts in the user's voice.",
+      argumentHint: "[post idea or source material]",
+      skillMd: createPostSkillMd(),
+    },
+  ].map((command) => ({
+    ...command,
+    content: claudeCommandMd(command),
+  }));
+}
+
 function writeCodexPluginSkills(pluginRoot, opts) {
   const skills = codexPluginSkills();
   const currentSkillDirs = new Set(skills.map((skill) => skill.dir));
@@ -1982,6 +2129,7 @@ function writeClaudeCustomAgents(opts) {
   for (const agent of claudeCustomAgents()) {
     writeFile(join(home, "agents", agent.filename), agent.content, opts);
   }
+  writeClaudeCommands(opts);
   for (const agent of legacyClaudeCustomAgents()) {
     const legacyPath = join(home, "agents", agent.filename);
     logVerbose(
@@ -1992,6 +2140,13 @@ function writeClaudeCustomAgents(opts) {
   removeLegacyClaudeCommands(home, opts);
 }
 
+function writeClaudeCommands(opts) {
+  const home = claudeHome();
+  for (const command of claudeCommands()) {
+    writeFile(join(home, "commands", command.filename), command.content, opts);
+  }
+}
+
 function removeLegacyClaudeCommands(home, opts) {
   for (const command of legacyClaudeCommands()) {
     const commandPath = join(home, "commands", command.filename);
@@ -2277,12 +2432,15 @@ function installClaude(opts) {
     throw new Error(message);
   }
   writeClaudeCustomAgents(opts);
+  removeClaudeMcp(opts);
   if (opts.server === "hosted") {
     run(
       "claude",
       [
         "mcp",
         "add",
+        "--scope",
+        "user",
         "--transport",
         "http",
         "sellable",
@@ -2294,14 +2452,20 @@ function installClaude(opts) {
     return true;
   }
   const [command, args] = mcpCommand(opts);
-  run("claude", ["mcp", "remove", "sellable"], {
-    ...opts,
-    dryRun: opts.dryRun,
-    allowFail: true,
-  });
   run(
     "claude",
-    ["mcp", "add", "--transport", "stdio", "sellable", "--", command, ...args],
+    [
+      "mcp",
+      "add",
+      "--scope",
+      "user",
+      "--transport",
+      "stdio",
+      "sellable",
+      "--",
+      command,
+      ...args,
+    ],
     opts
   );
   // Patch ~/.claude.json to add `alwaysLoad: true` so Claude Code v2.1.121+
@@ -2312,6 +2476,63 @@ function installClaude(opts) {
   return true;
 }
 
+function removeClaudeMcp(opts) {
+  for (const scope of ["local", "project", "user"]) {
+    run("claude", ["mcp", "remove", "--scope", scope, "sellable"], {
+      ...opts,
+      dryRun: opts.dryRun,
+      allowFail: true,
+    });
+  }
+}
+
+function canonicalClaudeMcpServer(opts) {
+  if (opts.server === "hosted") {
+    return {
+      type: "http",
+      url: withHostedWatchModeDriver(opts.hostedUrl, "claude"),
+      alwaysLoad: true,
+    };
+  }
+
+  const [command, args] = mcpCommand(opts);
+  return {
+    type: "stdio",
+    command,
+    args,
+    env: { SELLABLE_WATCH_MODE_DRIVER: "claude" },
+    alwaysLoad: true,
+  };
+}
+
+function collectClaudeSellableServers(config) {
+  const servers = [];
+  if (config?.mcpServers?.sellable) {
+    servers.push(config.mcpServers.sellable);
+  }
+  for (const projectPath of Object.keys(config?.projects || {})) {
+    const server = config.projects[projectPath]?.mcpServers?.sellable;
+    if (server) {
+      servers.push(server);
+    }
+  }
+  return servers;
+}
+
+function claudeMcpServerMatches(server, canonical) {
+  if (!server || typeof server !== "object") return false;
+  if (server.alwaysLoad !== true) return false;
+  if (canonical.type === "http") {
+    return server.type === canonical.type && server.url === canonical.url;
+  }
+  return (
+    server.type === canonical.type &&
+    server.command === canonical.command &&
+    JSON.stringify(server.args || []) === JSON.stringify(canonical.args) &&
+    server.env?.SELLABLE_WATCH_MODE_DRIVER === "claude"
+  );
+}
+
 function patchClaudeAlwaysLoad(opts) {
   if (opts.dryRun) {
     logVerbose(
@@ -2329,18 +2550,44 @@ function patchClaudeAlwaysLoad(opts) {
   try {
     const raw = readFileSync(claudeJsonPath, "utf8");
     const config = JSON.parse(raw);
+    const canonical = canonicalClaudeMcpServer(opts);
     let touched = false;
     const patchSellableServer = (server) => {
       if (!server || typeof server !== "object") return;
-      if (server.alwaysLoad !== true) {
-        server.alwaysLoad = true;
-        touched = true;
-      }
-      const isHttpServer =
-        typeof server.url === "string" ||
-        server.type === "http" ||
-        server.transport === "http";
-      if (!isHttpServer) {
+      if (opts.server === "hosted") {
+        for (const staleKey of ["command", "args", "env"]) {
+          if (staleKey in server) {
+            delete server[staleKey];
+            touched = true;
+          }
+        }
+        if (server.type !== canonical.type) {
+          server.type = canonical.type;
+          touched = true;
+        }
+        if (server.url !== canonical.url) {
+          server.url = canonical.url;
+          touched = true;
+        }
+      } else {
+        for (const staleKey of ["url"]) {
+          if (staleKey in server) {
+            delete server[staleKey];
+            touched = true;
+          }
+        }
+        if (server.type !== canonical.type) {
+          server.type = canonical.type;
+          touched = true;
+        }
+        if (server.command !== canonical.command) {
+          server.command = canonical.command;
+          touched = true;
+        }
+        if (JSON.stringify(server.args || []) !== JSON.stringify(canonical.args)) {
+          server.args = [...canonical.args];
+          touched = true;
+        }
         const existingDriver = server.env?.SELLABLE_WATCH_MODE_DRIVER;
         server.env = {
           ...(server.env && typeof server.env === "object" ? server.env : {}),
@@ -2350,12 +2597,16 @@ function patchClaudeAlwaysLoad(opts) {
           touched = true;
         }
       }
+      if (server.alwaysLoad !== true) {
+        server.alwaysLoad = true;
+        touched = true;
+      }
     };
-    // Top-level mcpServers.sellable (older claude versions)
+    // Top-level mcpServers.sellable (user scope)
     if (config.mcpServers?.sellable) {
       patchSellableServer(config.mcpServers.sellable);
     }
-    // Per-project mcpServers.sellable (current claude default)
+    // Per-project mcpServers.sellable (old local/project installs)
     for (const projectPath of Object.keys(config.projects || {})) {
       const projServers = config.projects[projectPath]?.mcpServers;
       if (projServers?.sellable) {
@@ -2469,6 +2720,34 @@ async function verify(opts) {
           : "Claude custom agent MCP tool allowlists missing"
       )
     );
+    const claudeCommandPaths = claudeCommands().map((command) =>
+      join(claudeHome(), "commands", command.filename)
+    );
+    const hasClaudeCommands = claudeCommandPaths.every((commandPath) =>
+      existsSync(commandPath)
+    );
+    checks.push(
+      warningCheck(
+        hasClaudeCommands,
+        hasClaudeCommands
+          ? "Claude slash commands present"
+          : "Claude slash commands missing"
+      )
+    );
+    const claudeCommandsHaveCurrentNames = claudeCommands().every((command) => {
+      const commandPath = join(claudeHome(), "commands", command.filename);
+      if (!existsSync(commandPath)) return false;
+      const content = readFileSync(commandPath, "utf8");
+      return content.includes(`name: sellable:${command.name}`);
+    });
+    checks.push(
+      warningCheck(
+        claudeCommandsHaveCurrentNames,
+        claudeCommandsHaveCurrentNames
+          ? "Claude slash command names current"
+          : "Claude slash command names stale"
+      )
+    );
     const legacyClaudePaths = [
       ...legacyClaudeCustomAgents().map((agent) =>
         join(claudeHome(), "agents", agent.filename)
@@ -2504,6 +2783,25 @@ async function verify(opts) {
           : "Claude watch mode driver missing"
       )
     );
+    let claudeMcpEntriesCanonical = false;
+    try {
+      const config = claudeConfigContent ? JSON.parse(claudeConfigContent) : {};
+      const servers = collectClaudeSellableServers(config);
+      const canonical = canonicalClaudeMcpServer(opts);
+      claudeMcpEntriesCanonical =
+        servers.length > 0 &&
+        servers.every((server) => claudeMcpServerMatches(server, canonical));
+    } catch {
+      claudeMcpEntriesCanonical = false;
+    }
+    checks.push(
+      warningCheck(
+        claudeMcpEntriesCanonical,
+        claudeMcpEntriesCanonical
+          ? "Claude Sellable MCP entries canonical"
+          : "Claude Sellable MCP entries stale"
+      )
+    );
   }
   if (opts.host === "codex" || opts.host === "all") {
     const hasCodexCli = commandExists("codex");
@@ -2690,8 +2988,8 @@ async function verify(opts) {
       (runtimeRequired ? requiredCheck : warningCheck)(
         runtimeMcp.ok,
         runtimeMcp.ok
-          ? `MCP runtime exposes required tools (${runtimeMcp.availableTools.length} total)`
-          : `MCP runtime missing tools: ${runtimeMcp.missingTools.join(", ") || runtimeMcp.error || "unknown failure"}`
+          ? `MCP runtime exposes required campaign tools (${runtimeMcp.availableTools.length} total) and create-campaign smoke passed`
+          : `MCP runtime verification failed: ${runtimeMcp.missingTools.join(", ") || runtimeMcp.createCampaignSmoke?.error || runtimeMcp.error || "unknown failure"}`
       )
     );
   }
@@ -2886,7 +3184,9 @@ function printNextSteps(installedHosts, authReused) {
     console.log(`        ${C.green}✓${C.reset} Codex custom agents installed`);
   }
   if (hasClaude) {
-    console.log(`        ${C.green}✓${C.reset} Claude custom agents installed`);
+    console.log(
+      `        ${C.green}✓${C.reset} Claude slash commands and custom agents installed`
+    );
   }
   if (authReused) {
     console.log(
@@ -3200,6 +3500,45 @@ async function main() {
       console.log(`    Codex: $sellable:create-post`);
       process.exit(0);
     }
+    if (rawArgs[0] === "prefs") {
+      const dryRun = rawArgs.includes("--dry-run");
+      const args = rawArgs.filter((arg) => arg !== "--dry-run");
+      if (
+        args[1] !== "set" ||
+        args[2] !== "prompt-sharing" ||
+        (args[3] !== "true" && args[3] !== "false") ||
+        args.length !== 4
+      ) {
+        console.error(
+          "Usage: sellable prefs set prompt-sharing true|false [--dry-run]"
+        );
+        process.exit(2);
+      }
+      const envPath = writePromptSharingPreference(args[3], { dryRun });
+      console.log(
+        `✓ Sellable prompt sharing preference set to ${args[3]} at ${envPath}`
+      );
+      process.exit(0);
+    }
+    if (rawArgs[0] === "setup") {
+      const dryRun = rawArgs.includes("--dry-run");
+      const args = rawArgs.filter((arg) => arg !== "--dry-run");
+      if (args[1] !== "claude-permissions") {
+        console.error(
+          `Unknown setup subcommand: ${args[1] ?? "(none)"}\nKnown: claude-permissions`
+        );
+        process.exit(2);
+      }
+      if (!args.includes("--allow-common-setup")) {
+        console.error(
+          "Usage: sellable setup claude-permissions --allow-common-setup [--dry-run]"
+        );
+        process.exit(2);
+      }
+      const settingsPath = allowClaudeCommonSetup({ dryRun });
+      console.log(`✓ Claude Sellable permissions updated at ${settingsPath}`);
+      process.exit(0);
+    }
     if (rawArgs[0] === "uninstall") {
       runUninstall();
       process.exit(0);

package/lib/runtime-verify.mjs

@@ -6,12 +6,64 @@ const DEFAULT_VERIFY_TIMEOUT_MS = 10_000;
 
 export const REQUIRED_SELLABLE_MCP_TOOLS = [
   "get_auth_status",
+  "start_cli_login",
+  "wait_for_cli_login",
   "bootstrap_create_campaign",
+  "get_subskill_prompt",
+  "get_subskill_asset",
+  "search_subskill_prompts",
   "create_campaign",
   "import_leads",
+  "confirm_lead_list",
+  "wait_for_lead_list_ready",
+  "wait_for_campaign_table_ready",
   "update_campaign",
-  "get_subskill_prompt",
-  "get_subskill_asset",
+  "update_campaign_brief",
+  "get_campaign",
+  "get_campaign_context",
+  "get_campaign_framework",
+  "get_campaign_navigation_state",
+  "get_campaign_messages_preview",
+  "attach_sequence",
+  "attach_recommended_sequence",
+  "start_campaign_message_preparation",
+  "get_campaign_message_preparation_status",
+  "cancel_campaign_message_preparation",
+  "start_campaign",
+];
+
+export const CREATE_CAMPAIGN_SMOKE_CALLS = [
+  {
+    name: "get_auth_status",
+    arguments: {},
+  },
+  {
+    name: "bootstrap_create_campaign",
+    arguments: {
+      flowVersion: "v2",
+      includeTableCheck: false,
+      host: "sellable-install-verify",
+      model: "installer-smoke",
+      reasoningEffort: "none",
+    },
+  },
+  {
+    name: "get_subskill_prompt",
+    arguments: {
+      subskillName: "create-campaign-v2",
+      offset: 0,
+      limit: 1200,
+    },
+  },
+  {
+    name: "get_subskill_asset",
+    arguments: {
+      subskillName: "create-campaign-v2",
+      assetPath: "core/flow.v2.json",
+      offset: 0,
+      limit: 1200,
+    },
+  },
 ];
 
 function collectStderrLines(stream) {
@@ -73,6 +125,172 @@ export function missingRequiredTools(tools, requiredTools) {
   return requiredTools.filter((name) => !available.has(name));
 }
 
+function textFromToolResult(result) {
+  return (result?.content || [])
+    .filter((part) => part?.type === "text" && typeof part.text === "string")
+    .map((part) => part.text)
+    .join("\n");
+}
+
+function parseJsonText(text) {
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function summarizeToolResult(name, result) {
+  const text = redact(textFromToolResult(result));
+  const parsed = parseJsonText(text);
+  const summary = {
+    isError: result?.isError === true,
+    textChars: text.length,
+  };
+
+  if (name === "get_auth_status" && parsed) {
+    return {
+      ...summary,
+      authOk: parsed.ok === true,
+      errorType: parsed.error?.type || null,
+      activeWorkspaceId: parsed.activeWorkspaceId || null,
+      activeWorkspaceName: parsed.activeWorkspaceName || null,
+    };
+  }
+
+  if (name === "bootstrap_create_campaign" && parsed) {
+    return {
+      ...summary,
+      safeToProceed: parsed.safeToProceed === true,
+      flowVersion: parsed.flowVersion || null,
+      blockingChecks: Array.isArray(parsed.blockingErrors)
+        ? parsed.blockingErrors.map((entry) => entry?.check).filter(Boolean)
+        : [],
+      requiredChecks: Array.isArray(parsed.requiredChecks)
+        ? parsed.requiredChecks.map((entry) => ({
+            key: entry?.key || null,
+            ok: entry?.ok === true,
+            blocking: entry?.blocking === true,
+          }))
+        : [],
+      nextStepChars:
+        typeof parsed.nextStep === "string" ? parsed.nextStep.length : 0,
+    };
+  }
+
+  if (name === "get_subskill_prompt" && parsed) {
+    return {
+      ...summary,
+      subskillName: parsed.name || null,
+      promptChars: typeof parsed.prompt === "string" ? parsed.prompt.length : 0,
+      hasMore: parsed.hasMore === true,
+      nextOffset:
+        typeof parsed.nextOffset === "number" ? parsed.nextOffset : null,
+    };
+  }
+
+  if (name === "get_subskill_asset" && parsed) {
+    return {
+      ...summary,
+      subskillName: parsed.subskillName || null,
+      assetPath: parsed.assetPath || null,
+      assetChars: typeof parsed.content === "string" ? parsed.content.length : 0,
+      hasMore: parsed.hasMore === true,
+      nextOffset:
+        typeof parsed.nextOffset === "number" ? parsed.nextOffset : null,
+    };
+  }
+
+  return summary;
+}
+
+async function verifyCreateCampaignSmoke({
+  client,
+  availableTools,
+  timeoutMs,
+  smokeCalls = CREATE_CAMPAIGN_SMOKE_CALLS,
+}) {
+  const startedAt = new Date().toISOString();
+  const available = new Set(availableTools || []);
+  const missingTools = smokeCalls
+    .map((call) => call.name)
+    .filter((name) => !available.has(name));
+  const calls = [];
+
+  if (missingTools.length > 0) {
+    return {
+      ok: false,
+      missingTools,
+      calls,
+      error: `Missing smoke tool(s): ${missingTools.join(", ")}`,
+      startedAt,
+      completedAt: new Date().toISOString(),
+    };
+  }
+
+  for (const call of smokeCalls) {
+    const callStartedAt = new Date().toISOString();
+    try {
+      const result = await client.callTool(
+        { name: call.name, arguments: call.arguments },
+        undefined,
+        {
+          timeout: timeoutMs,
+          maxTotalTimeout: timeoutMs,
+        }
+      );
+      const summary = summarizeToolResult(call.name, result);
+      calls.push({
+        name: call.name,
+        arguments: call.arguments,
+        ok: summary.isError !== true,
+        summary,
+        startedAt: callStartedAt,
+        completedAt: new Date().toISOString(),
+      });
+      if (summary.isError === true) {
+        return {
+          ok: false,
+          missingTools: [],
+          calls,
+          error: `${call.name} returned an MCP tool error`,
+          startedAt,
+          completedAt: new Date().toISOString(),
+        };
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      calls.push({
+        name: call.name,
+        arguments: call.arguments,
+        ok: false,
+        summary: null,
+        error: redact(error),
+        startedAt: callStartedAt,
+        completedAt: new Date().toISOString(),
+      });
+      return {
+        ok: false,
+        missingTools: [],
+        calls,
+        error: redact(error),
+        startedAt,
+        completedAt: new Date().toISOString(),
+      };
+    }
+  }
+
+  return {
+    ok: true,
+    missingTools: [],
+    calls,
+    error: null,
+    startedAt,
+    completedAt: new Date().toISOString(),
+  };
+}
+
 export async function verifySellableMcpRuntime({
   command,
   args = [],
@@ -116,6 +334,7 @@ export async function verifySellableMcpRuntime({
 
   let availableTools = [];
   let missingTools = [...requiredTools];
+  let createCampaignSmoke = null;
   let error = null;
 
   try {
@@ -126,6 +345,25 @@ export async function verifySellableMcpRuntime({
     });
     availableTools = toolList.tools.map((tool) => tool.name).sort();
     missingTools = missingRequiredTools(toolList.tools, requiredTools);
+    if (missingTools.length === 0) {
+      createCampaignSmoke = await verifyCreateCampaignSmoke({
+        client,
+        availableTools,
+        timeoutMs,
+      });
+    } else {
+      createCampaignSmoke = {
+        ok: false,
+        missingTools: CREATE_CAMPAIGN_SMOKE_CALLS.map((call) => call.name).filter(
+          (name) => !availableTools.includes(name)
+        ),
+        calls: [],
+        error:
+          "Skipping create-campaign smoke because required MCP tools are missing.",
+        startedAt: new Date().toISOString(),
+        completedAt: new Date().toISOString(),
+      };
+    }
   } catch (err) {
     error = err instanceof Error ? err.message : String(err);
   } finally {
@@ -137,13 +375,14 @@ export async function verifySellableMcpRuntime({
   }
 
   return {
-    ok: !error && missingTools.length === 0,
+    ok: !error && missingTools.length === 0 && createCampaignSmoke?.ok === true,
     skipped: false,
     command,
     args,
     requiredTools,
     availableTools,
     missingTools,
+    createCampaignSmoke,
     stderrTail: stderrLines,
     error: error ? redact(error) : null,
     startedAt,

package/package.json

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