@sellable/install 0.1.303 → 0.1.304

package/bin/sellable-install.mjs

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
+import { createHash } from "node:crypto";
 import { spawnSync } from "node:child_process";
 import {
+  chmodSync,
   cpSync,
   existsSync,
   mkdirSync,
@@ -11,10 +13,11 @@ import {
   writeFileSync,
 } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join, relative } from "node:path";
+import { dirname, join, relative, resolve } from "node:path";
 import { stdout as output } from "node:process";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
+import { parseDocument } from "yaml";
 import {
   REQUIRED_SELLABLE_MCP_TOOLS,
   verifySellableMcpRuntime,
@@ -167,14 +170,20 @@ Commands:
                            Save the ask-first prompt-sharing preference.
   setup claude-permissions --allow-common-setup
                            Add common Sellable Bash permissions to Claude settings.
+  hermes profile bootstrap  Create a profile-local Hermes config, Sellable auth config,
+                           configs dir, skills, and optional Slack .env.
   uninstall                Remove Sellable host config and installed artifacts.
 
 Options:
-  --host <host>             claude, codex, or all. Default: all
+  --host <host>             claude, codex, hermes, or all. Default: all
   --server <mode>           package, local, or hosted. Default: package
   --token <token>           Sellable API token. Also reads SELLABLE_TOKEN.
   --workspace-id <id>       Sellable workspace id. Also reads SELLABLE_WORKSPACE_ID.
   --api-url <url>           Sellable API URL. Default: ${DEFAULT_API_URL}
+  --sellable-config-path <path>
+                            Profile-scoped Sellable config path. Also reads SELLABLE_CONFIG_PATH.
+  --sellable-configs-dir <path>
+                            Profile-scoped Sellable configs/memory dir. Also reads SELLABLE_CONFIGS_DIR.
   --mcp-package <pkg>       MCP server package. Default: ${DEFAULT_SERVER_PACKAGE}
   --local-command <cmd>     Local MCP command for --server local.
   --hosted-url <url>        Hosted MCP URL for --server hosted.
@@ -190,20 +199,33 @@ Options:
 Auth:
   Install is auth-free by default. Sign in happens on the first run of
   /sellable:create-campaign, /sellable:create-evergreen-campaigns,
-  /sellable:foundation, /sellable:content, /sellable:create-post, or
-  /sellable:refresh-sender-engagement, or /sellable:refill-sends in Claude Code or Codex,
+  /sellable:foundation, /sellable:content, /sellable:create-post,
+  /sellable:refresh-sender-engagement, or /sellable:refill-sends in Claude Code,
+  Codex, or Hermes,
   where the agent walks you through signup or sign-in and stores credentials
   in ~/.sellable/config.json.
 
   For CI/scripted installs, pass --token + --workspace-id or set
   SELLABLE_TOKEN + SELLABLE_WORKSPACE_ID and the installer will write the
-  config file directly without prompting.
+  config file directly without prompting. For Hermes customer/admin profiles,
+  also pass --sellable-config-path or set SELLABLE_CONFIG_PATH so auth and MCP
+  runtime use the same profile-local config file.
+
+Hermes profile bootstrap:
+  sellable hermes profile bootstrap --profile acme --profiles-root /srv/hermes/profiles --workspace-id ws_acme --token-file /run/secrets/sellable-token --json
+  sellable hermes profile bootstrap --profile-root "$HOME/.hermes/profiles/acme" --workspace-id ws_acme --json
+
+  Bootstrap writes <profileRoot>/config.yaml, <profileRoot>/sellable/config.json,
+  <profileRoot>/sellable/configs, Sellable Hermes skills, and optional
+  <profileRoot>/.env Slack token keys. Use customer-scoped Sellable credentials
+  for customer profiles; a shared admin token is weaker isolation and should
+  remain internal-only.
 `;
 }
 
 function printCreateCommandHint() {
   printBanner();
-  console.log(`  ${C.bold}Run Sellable from Claude Code or Codex.${C.reset}`);
+  console.log(`  ${C.bold}Run Sellable from Claude Code, Codex, or Hermes.${C.reset}`);
   console.log("");
   console.log(
     `  ${C.grey}The terminal command installs and verifies Sellable. Campaign creation runs inside your agent session so the workflow can use MCP tools, live state, and approval gates.${C.reset}`
@@ -237,6 +259,18 @@ function printCreateCommandHint() {
     { label: "Refill", command: "$sellable:refill-sends" },
   ]);
   console.log("");
+  console.log("");
+  printAgentBox("Using Hermes?", "hermes", [
+    { label: "Campaign", command: "/sellable-create-campaign" },
+    { label: "A/B Test", command: "/sellable-create-ab-test" },
+    { label: "Evergreen", command: "/sellable-create-evergreen-campaigns" },
+    { label: "Foundation", command: "/sellable-foundation" },
+    { label: "Content", command: "/sellable-content" },
+    { label: "Post", command: "/sellable-create-post" },
+    { label: "Refresh", command: "/sellable-refresh-sender-engagement" },
+    { label: "Refill", command: "/sellable-refill-sends" },
+  ]);
+  console.log("");
   console.log(`   ${"─".repeat(63)}`);
   console.log(`    ${C.grey}If those commands are missing, run:${C.reset}`);
   console.log("");
@@ -249,11 +283,16 @@ function printCreateCommandHint() {
 
 function parseArgs(argv) {
   const opts = {
-    host: process.env.SELLABLE_INSTALL_HOST || "all",
+    host:
+      process.env.SELLABLE_INSTALLER_HOST ||
+      process.env.SELLABLE_INSTALL_HOST ||
+      "all",
     server: process.env.SELLABLE_INSTALL_SERVER || "package",
     token: process.env.SELLABLE_TOKEN || "",
     workspaceId: process.env.SELLABLE_WORKSPACE_ID || "",
     apiUrl: process.env.SELLABLE_API_URL || DEFAULT_API_URL,
+    sellableConfigPath: process.env.SELLABLE_CONFIG_PATH || "",
+    sellableConfigsDir: process.env.SELLABLE_CONFIGS_DIR || "",
     mcpPackage: DEFAULT_SERVER_PACKAGE,
     localCommand: process.env.SELLABLE_MCP_LOCAL_COMMAND || "",
     hostedUrl: process.env.SELLABLE_MCP_HOSTED_URL || "",
@@ -288,6 +327,10 @@ function parseArgs(argv) {
       opts.workspaceId = next();
     } else if (arg === "--api-url") {
       opts.apiUrl = next();
+    } else if (arg === "--sellable-config-path") {
+      opts.sellableConfigPath = next();
+    } else if (arg === "--sellable-configs-dir") {
+      opts.sellableConfigsDir = next();
     } else if (arg === "--mcp-package") {
       opts.mcpPackage = normalizeWindowsPackageSpec(next());
     } else if (arg === "--local-command") {
@@ -313,12 +356,17 @@ function parseArgs(argv) {
     }
   }
 
-  if (!["claude", "codex", "all"].includes(opts.host)) {
-    throw new Error("--host must be claude, codex, or all");
+  if (!["claude", "codex", "hermes", "all"].includes(opts.host)) {
+    throw new Error("--host must be claude, codex, hermes, or all");
   }
   if (!["package", "local", "hosted"].includes(opts.server)) {
     throw new Error("--server must be package, local, or hosted");
   }
+  opts.sellableConfigPath = normalizeOptionalPath(opts.sellableConfigPath);
+  opts.sellableConfigsDir = normalizeOptionalPath(opts.sellableConfigsDir);
+  if (opts.sellableConfigPath && !opts.sellableConfigsDir) {
+    opts.sellableConfigsDir = join(dirname(opts.sellableConfigPath), "configs");
+  }
 
   return opts;
 }
@@ -576,8 +624,17 @@ function getMcpVersion() {
   return "latest";
 }
 
-function authPath() {
-  return join(homedir(), ".sellable", "config.json");
+function normalizeOptionalPath(value) {
+  const trimmed = String(value || "").trim();
+  return trimmed ? resolve(trimmed) : "";
+}
+
+function authPath(opts = {}) {
+  return (
+    normalizeOptionalPath(opts.sellableConfigPath) ||
+    normalizeOptionalPath(process.env.SELLABLE_CONFIG_PATH) ||
+    join(homedir(), ".sellable", "config.json")
+  );
 }
 
 function normalizeStoredAuth(raw) {
@@ -598,15 +655,15 @@ function normalizeStoredAuth(raw) {
   };
 }
 
-function readStoredAuth() {
-  const raw = readExisting(authPath());
+function readStoredAuth(opts = {}) {
+  const raw = readExisting(authPath(opts));
   return raw ? normalizeStoredAuth(raw) : null;
 }
 
 async function loadAuthIfPresent(opts) {
   if (opts.token && opts.workspaceId) return opts;
 
-  const stored = readStoredAuth();
+  const stored = readStoredAuth(opts);
   if (stored?.token && stored?.workspaceId) {
     opts.token ||= stored.token;
     opts.workspaceId ||= stored.workspaceId;
@@ -670,7 +727,7 @@ function mergeAuthConfig(raw, auth) {
       Array.isArray(envConfig)
     ) {
       throw new Error(
-        `Unknown active environment '${activeEnv}' in ${authPath()}`
+        `Unknown active environment '${activeEnv}' in configured Sellable auth path`
       );
     }
     return {
@@ -691,8 +748,14 @@ function mergeAuthConfig(raw, auth) {
   };
 }
 
-function writeAuthSetConfig({ token, workspaceId, apiUrl, dryRun }) {
-  const configPath = authPath();
+function writeAuthSetConfig({
+  token,
+  workspaceId,
+  apiUrl,
+  dryRun,
+  sellableConfigPath,
+}) {
+  const configPath = authPath({ sellableConfigPath });
   const raw = readExisting(configPath) || {};
   const config = mergeAuthConfig(raw, {
     token,
@@ -843,6 +906,7 @@ function writeFile(path, content, opts, mode = 0o644) {
   if (opts.dryRun) return;
   mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
   writeFileSync(path, content, { mode });
+  chmodSync(path, mode);
 }
 
 function ensureSymlink(target, linkPath, opts) {
@@ -935,9 +999,7 @@ function codexPluginMcp(opts) {
           type: "stdio",
           command,
           args,
-          env: {
-            SELLABLE_WATCH_MODE_DRIVER: "codex",
-          },
+          env: mcpEnvForHost("codex", opts),
         },
       },
     };
@@ -950,9 +1012,7 @@ function codexPluginMcp(opts) {
         type: "stdio",
         command,
         args,
-        env: {
-          SELLABLE_WATCH_MODE_DRIVER: "codex",
-        },
+        env: mcpEnvForHost("codex", opts),
       },
     },
   };
@@ -1175,6 +1235,29 @@ the Claude Code instruction for customer-facing language and host functions.
 
 Do not tell Claude Code users to run \`$sellable:${commandName}\`, use
 \`request_user_input\`, or restart Codex Desktop. Do not describe this run as Codex.`;
+  }
+  if (host === "hermes") {
+    return `## Installed Host Contract
+
+This installed skill is running in Hermes Agent. When the shared workflow body
+or fallback text mentions Claude Code, Codex, or Hermes for internal parity,
+choose the Hermes instruction for customer-facing language and host functions.
+
+- Customer-facing command: \`/sellable-${commandName}\`
+- MCP tool naming: Hermes exposes Sellable tools as \`mcp_sellable_<tool>\`;
+  when shared instructions show \`mcp__sellable__<tool>\`, call the matching
+  \`mcp_sellable_<tool>\` tool instead.
+- Structured questions: ask plainly in chat unless a Hermes-native approval or
+  question tool is visible in the current session.
+- Bootstrap host label: \`host: "Hermes"\`
+- Install/reload blocker label: Hermes install/reload problem
+- Reload instruction: restart Hermes, or run \`/reload-mcp\` in the active
+  Hermes session after install
+
+Do not tell Hermes users to run \`$sellable:${commandName}\` or
+\`/sellable:${commandName}\`, use \`AskUserQuestion\` or \`request_user_input\`,
+or restart Claude Code or Codex Desktop. Do not describe this run as Claude Code
+or Codex.`;
   }
   return "";
 }
@@ -2584,6 +2667,256 @@ function codexPluginSkills() {
   ];
 }
 
+function hermesCommandName(commandName) {
+  return `sellable-${commandName}`;
+}
+
+function normalizeHermesSkillMarkdown(markdown, commandName) {
+  const hermesName = hermesCommandName(commandName);
+  let content = String(markdown);
+  if (/^name:\s*.+$/m.test(content)) {
+    content = content.replace(/^name:\s*.+$/m, `name: ${hermesName}`);
+  } else {
+    content = content.replace(/^---\n/m, `---\nname: ${hermesName}\n`);
+  }
+
+  let normalized = content
+    .replace(/mcp__sellable__<tool>/g, "mcp_sellable_<tool>")
+    .replace(/mcp__([A-Za-z0-9_-]+)__<tool>/g, (_, server) => {
+      return `mcp_${String(server).replaceAll("-", "_")}_<tool>`;
+    })
+    .replace(/\bmcp__([A-Za-z0-9_-]+)__([A-Za-z0-9_-]+)\b/g, (_, server, tool) => {
+      return `mcp_${String(server).replaceAll("-", "_")}_${String(tool).replaceAll("-", "_")}`;
+    })
+    .replace(/\bmcp__sellable__/g, "mcp_sellable_")
+    .replace(/\$sellable:/g, "/sellable-")
+    .replace(/\/sellable:/g, "/sellable-")
+    .replace(/Codex install\/reload problem/g, "Hermes install/reload problem")
+    .replace(/Claude Code install\/reload problem/g, "Hermes install/reload problem")
+    .replace(/fully quit and reopen Codex Desktop, then start a new thread/g, "restart Hermes, or run `/reload-mcp` in the active Hermes session")
+    .replace(/fully quit and reopen Claude Code, then start a new session/g, "restart Hermes, or run `/reload-mcp` in the active Hermes session")
+    .replace(/Codex Desktop/g, "Hermes")
+    .replace(/Claude Code\/Codex/g, "Hermes")
+    .replace(/Claude Code or Codex/g, "Hermes")
+    .replace(/Codex or Claude Code/g, "Hermes")
+    .replace(/Claude Code and Codex/g, "Hermes")
+    .replace(/Codex\/Claude/g, "Hermes")
+    .replace(/quick question panel/g, "approval prompt")
+    .replace(/request_user_input/g, "plain chat")
+    .replace(/AskUserQuestion/g, "plain chat");
+
+  normalized = normalized.replace(
+    /Do not tell Hermes users to run[\s\S]*?Do not describe this run as Claude Code\nor Codex\./g,
+    "Do not tell Hermes users to run Codex or Claude command forms, use Codex/Claude structured-question APIs, or restart Codex Desktop or Claude Code. Do not describe this run as Claude Code or Codex."
+  );
+
+  normalized = normalized.replace(
+    /## Structured Questions\n\nUse the host-native structured question gate for intake and approval:[\s\S]*?## Host Runtime Functions/g,
+    `## Structured Questions
+
+Hermes should ask setup questions directly in chat unless the current Hermes
+session exposes a native approval or question tool. Use a bounded approval gate
+only for explicit approval decisions. For open text like LinkedIn URLs, company
+domains, notes, pasted context, campaign ideas, or feedback, ask in normal chat
+and wait for the user to paste the value.
+
+Campaign setup questions are single-choice decisions. Use mutually exclusive
+options and route blended or custom answers through a short free-text follow-up.
+Customer-facing language should call this "a couple setup choices" during
+normal campaign progress.
+
+## Host Runtime Functions`
+  );
+
+  normalized = normalized.replace(
+    /## Names To Use\n\nUse these exact public names[\s\S]*?## Structured Questions/g,
+    `## Names To Use
+
+Use these exact public names for Hermes:
+
+- Hermes command: \`/${hermesName}\`
+- Hermes skill directory: \`skills/sellable/${hermesName}/SKILL.md\`
+- MCP server name: \`sellable\`
+- Hermes MCP tool prefix: \`mcp_sellable_\`
+- Internal workflow prompt: \`create-campaign-v2\`
+
+Do not tell users to run internal subskill names. \`create-campaign-v2\` is only
+the internal subskill loaded through
+\`mcp_sellable_get_subskill_prompt({ subskillName: "create-campaign-v2" })\`.
+
+## Structured Questions`
+  );
+
+  normalized = normalized.replace(
+    /- `ask_user`:[\s\S]*?(?=\n- `load_subprompt`:)/g,
+    `- \`ask_user\`: ask directly in chat unless a Hermes-native approval or
+  question tool is visible in the current session. Use this for
+  multiple-choice intake, campaign-focus choices, source decisions, and
+  approvals. Campaign setup questions are single-choice only; do not use
+  multi-select or checkbox variants.`
+  );
+
+  normalized = normalized.replace(
+    /- `launch_message_drafting`:[\s\S]*?\n\nIf a required interactive/g,
+    `- \`launch_message_drafting\`: if Hermes exposes a background-agent capability,
+  use the compatible Message Drafting agent. Otherwise run the same message
+  drafting branch inline in the parent session with \`statusSource:
+  "parent-thread-fallback"\`.
+
+If a required interactive`
+  );
+
+  normalized = normalized.replace(
+    /Do not silently ask (?:Codex|Hermes) intake or approval questions as plain chat[\s\S]*?Plain chat questions are only acceptable in non-interactive `codex exec`\nsmoke\/rehearsal runs because structured user input is unavailable by design\nthere\.\n\n/g,
+    ""
+  );
+
+  normalized = normalized.replace(
+    /## Active Model Metadata\n\nBefore calling `bootstrap_create_campaign`, collect[\s\S]*?Never invent the model or reasoning effort\. Never pass config defaults as active\nmetadata\. If bootstrap returns `modelQuality\.status === "unknown"`, continue\nwithout asking the user to switch models\.\n\n/g,
+    `## Active Model Metadata
+
+Before calling \`bootstrap_create_campaign\`, pass \`host: "Hermes"\`. If the
+current Hermes session exposes model and effort metadata for this same turn,
+pass those exact values with \`modelMetadataSource: "hermes_runtime_metadata"\`.
+If the current Hermes session context explicitly states both the exact model ID
+and effort/thinking level, pass them with
+\`modelMetadataSource: "hermes_session_context"\`. Otherwise omit \`model\`,
+\`reasoningEffort\`, and \`modelMetadataSource\`.
+
+Never invent the model or reasoning effort. Never inspect Codex or Claude config
+files as proof of the active Hermes session. If bootstrap returns
+\`modelQuality.status === "unknown"\`, continue without asking the user to
+switch models.
+
+`
+  );
+
+  normalized = normalized.replace(/not `plain chat`/g, "not internal API names");
+
+  normalized = normalized
+    .replace(/this is a Codex\ninstall\/reload problem/g, "this is a Hermes\ninstall/reload problem")
+    .replace(/Hermes plugin/g, "Hermes skills");
+
+  return normalized;
+}
+
+function compactHermesEvergreenSkillMd() {
+  return normalizeHermesSkillMarkdown(
+    stampInstalledHost(`---
+name: create-evergreen-campaigns
+description: Create or repair evergreen campaign lanes without launching sends.
+visibility: public
+allowed-tools:
+${allowedToolsYaml(CREATE_EVERGREEN_CAMPAIGNS_ALLOWED_TOOLS)}
+---
+
+# Sellable Create Evergreen Campaigns
+
+Use this as the customer-facing entrypoint for the Sellable
+\`create-evergreen-campaigns\` workflow in Hermes.
+
+## Bootstrap
+
+MCP prompt and command access are required. First call
+\`mcp__sellable__get_auth_status({})\`. Do not inspect repo files, run shell
+commands, use \`npm\`, \`node\`, local harness scripts, or read local prompt
+files to emulate this workflow.
+
+If the Sellable MCP prompt tools are unavailable, stop and say this is a Hermes
+install/reload problem. Tell the user to run
+\`curl -fsSL "https://app.sellable.dev/api/v2/cli/install" | sh\`, then restart
+Hermes or run \`/reload-mcp\`.
+
+## Execute Workflow
+
+1. Load the canonical prompt via
+   \`mcp__sellable__get_subskill_prompt({ subskillName: "create-evergreen-campaigns" })\`.
+   If the response has \`hasMore=true\`, continue with \`nextOffset\` until
+   \`hasMore=false\`.
+2. Ask for bounded approval in normal chat before mutating if the plan requires
+   approval. Do not call Codex app thread tools or Codex CLI workers from
+   Hermes.
+3. Use \`mcp__sellable__setup_evergreen_campaigns({ mode: "plan" })\` for the
+   plan/readback packet, then use the canonical prompt's approved mutation path
+   and return to \`setup_evergreen_campaigns({ mode: "verify" })\` with
+   customer-visible receipts.
+4. Do not launch campaigns, schedule sends, archive campaigns, delete tables,
+   or spend paid credits.
+
+## MCP Prompt Fallback
+
+If exact subskill lookup fails, use
+\`mcp__sellable__search_subskill_prompts({ query: "create-evergreen-campaigns", includePublic: true, includeInternal: true })\`,
+then retry \`get_subskill_prompt\`.
+`, "hermes", "create-evergreen-campaigns"),
+    "create-evergreen-campaigns"
+  );
+}
+
+function hermesSkillDefinitions() {
+  return [
+    {
+      commandName: "create-campaign",
+      dir: hermesCommandName("create-campaign"),
+      skillMd: normalizeHermesSkillMarkdown(
+        createCampaignSkillMd("hermes"),
+        "create-campaign"
+      ),
+      soulMd: createCampaignSoulMd(),
+    },
+    {
+      commandName: "create-ab-test",
+      dir: hermesCommandName("create-ab-test"),
+      skillMd: normalizeHermesSkillMarkdown(
+        createAbTestSkillMd("hermes"),
+        "create-ab-test"
+      ),
+    },
+    {
+      commandName: "create-evergreen-campaigns",
+      dir: hermesCommandName("create-evergreen-campaigns"),
+      skillMd: compactHermesEvergreenSkillMd(),
+    },
+    {
+      commandName: "foundation",
+      dir: hermesCommandName("foundation"),
+      skillMd: normalizeHermesSkillMarkdown(
+        foundationSkillMd("hermes"),
+        "foundation"
+      ),
+    },
+    {
+      commandName: "content",
+      dir: hermesCommandName("content"),
+      skillMd: normalizeHermesSkillMarkdown(contentSkillMd("hermes"), "content"),
+    },
+    {
+      commandName: "create-post",
+      dir: hermesCommandName("create-post"),
+      skillMd: normalizeHermesSkillMarkdown(
+        createPostSkillMd("hermes"),
+        "create-post"
+      ),
+    },
+    {
+      commandName: "refresh-sender-engagement",
+      dir: hermesCommandName("refresh-sender-engagement"),
+      skillMd: normalizeHermesSkillMarkdown(
+        refreshSenderEngagementSkillMd("hermes"),
+        "refresh-sender-engagement"
+      ),
+    },
+    {
+      commandName: "refill-sends",
+      dir: hermesCommandName("refill-sends"),
+      skillMd: normalizeHermesSkillMarkdown(
+        refillSendsSkillMd("hermes"),
+        "refill-sends"
+      ),
+    },
+  ];
+}
+
 function installerPackageRoot() {
   return join(dirname(fileURLToPath(import.meta.url)), "..");
 }
@@ -3095,7 +3428,7 @@ function writeAuth(opts) {
     activeWorkspaceId: opts.workspaceId,
     apiUrl: opts.apiUrl,
   };
-  writeJson(authPath(), config, opts);
+  writeJson(authPath(opts), config, opts);
   return { written: true, reused: false };
 }
 
@@ -3152,8 +3485,43 @@ exec ${shellQuote(npmCommand)} exec --yes --package ${shellQuote(INSTALL_PACKAGE
 const WATCH_MODE_DRIVER_ENV = {
   claude: "SELLABLE_WATCH_MODE_DRIVER=claude",
   codex: "SELLABLE_WATCH_MODE_DRIVER=codex",
+  hermes: "SELLABLE_WATCH_MODE_DRIVER=hermes",
 };
 
+function mcpEnvForHost(host, opts) {
+  const env = {
+    SELLABLE_WATCH_MODE_DRIVER: host,
+  };
+  if (opts.server === "hosted") return env;
+  if (opts.sellableConfigPath) {
+    env.SELLABLE_CONFIG_PATH = opts.sellableConfigPath;
+  }
+  if (opts.sellableConfigsDir) {
+    env.SELLABLE_CONFIGS_DIR = opts.sellableConfigsDir;
+  }
+  return env;
+}
+
+function mcpEnvVarArgs(host, opts) {
+  return Object.entries(mcpEnvForHost(host, opts)).map(
+    ([key, value]) => `${key}=${value}`
+  );
+}
+
+function tomlEnvTable(host, opts) {
+  return Object.entries(mcpEnvForHost(host, opts))
+    .map(([key, value]) => `${key} = ${quoteToml(value)}`)
+    .join("\n");
+}
+
+function runtimeMcpEnvForVerify(opts) {
+  const host =
+    opts.host === "claude" || opts.host === "codex" || opts.host === "hermes"
+      ? opts.host
+      : "codex";
+  return mcpEnvForHost(host, opts);
+}
+
 function withHostedWatchModeDriver(rawUrl, driver) {
   if (!WATCH_MODE_DRIVER_ENV[driver]) {
     throw new Error(`Unknown watch mode driver: ${driver}`);
@@ -3207,8 +3575,7 @@ function codexMcpAddArgs(opts) {
     "mcp",
     "add",
     "sellable",
-    "--env",
-    WATCH_MODE_DRIVER_ENV.codex,
+    ...mcpEnvVarArgs("codex", opts).flatMap((entry) => ["--env", entry]),
     "--",
     command,
     ...args,
@@ -3239,7 +3606,7 @@ args = ${tomlArray(args)}`
     content,
     "mcp_servers.sellable.env",
     `[mcp_servers.sellable.env]
-SELLABLE_WATCH_MODE_DRIVER = "codex"`
+${tomlEnvTable("codex", opts)}`
   );
   return content;
 }
@@ -3262,7 +3629,9 @@ function codexMcpServerMatches(content, opts) {
   return (
     server.includes(`command = ${quoteToml(command)}`) &&
     server.includes(`args = ${tomlArray(args)}`) &&
-    env.includes('SELLABLE_WATCH_MODE_DRIVER = "codex"')
+    Object.entries(mcpEnvForHost("codex", opts)).every(([key, value]) =>
+      env.includes(`${key} = ${quoteToml(value)}`)
+    )
   );
 }
 
@@ -3277,6 +3646,568 @@ function codexPluginMcpServerMatches(content, opts) {
   }
 }
 
+function hermesHome(opts = {}) {
+  return (
+    opts.hermesHome ||
+    process.env.HERMES_HOME?.trim() ||
+    join(homedir(), ".hermes")
+  );
+}
+
+function hermesConfigPath(opts = {}) {
+  return join(hermesHome(opts), "config.yaml");
+}
+
+function hermesSkillsRoot(opts = {}) {
+  return join(hermesHome(opts), "skills", "sellable");
+}
+
+function hermesLikelyInstalled() {
+  return (
+    Boolean(process.env.HERMES_HOME?.trim()) ||
+    commandExists("hermes") ||
+    existsSync(hermesConfigPath()) ||
+    existsSync(join(hermesHome(), "skills"))
+  );
+}
+
+function parseHermesConfig(raw, configPath = hermesConfigPath()) {
+  const source = raw.trim() ? raw : "{}\n";
+  const doc = parseDocument(source, { prettyErrors: false });
+  if (doc.errors.length > 0) {
+    throw new Error(
+      `Invalid Hermes config YAML at ${configPath}: ${doc.errors[0].message}`
+    );
+  }
+  const value = doc.toJSON() ?? {};
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(
+      `Invalid Hermes config YAML at ${configPath}: expected a mapping at the document root`
+    );
+  }
+  return value;
+}
+
+function readHermesConfig(opts = {}) {
+  const configPath = hermesConfigPath(opts);
+  const raw = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
+  return { raw, config: parseHermesConfig(raw, configPath), configPath };
+}
+
+function hermesMcpServer(opts) {
+  if (opts.server === "hosted") {
+    return {
+      url: withHostedWatchModeDriver(opts.hostedUrl, "hermes"),
+      enabled: true,
+      env: {
+        SELLABLE_WATCH_MODE_DRIVER: "hermes",
+      },
+    };
+  }
+
+  const [command, args] = mcpCommand(opts);
+  return {
+    command,
+    args,
+    enabled: true,
+    env: mcpEnvForHost("hermes", opts),
+  };
+}
+
+function writeHermesConfig(configPath, config, opts) {
+  if (opts.dryRun) return;
+  mkdirSync(dirname(configPath), { recursive: true, mode: 0o700 });
+  const doc = parseDocument("{}\n");
+  doc.contents = config;
+  writeFileSync(configPath, String(doc), { mode: 0o600 });
+}
+
+function writeHermesMcpServer(opts) {
+  const { config, configPath } = readHermesConfig(opts);
+  const existingMcpServers =
+    config.mcp_servers &&
+    typeof config.mcp_servers === "object" &&
+    !Array.isArray(config.mcp_servers)
+      ? config.mcp_servers
+      : {};
+  const nextConfig = {
+    ...config,
+    mcp_servers: {
+      ...existingMcpServers,
+      sellable: hermesMcpServer(opts),
+    },
+  };
+  writeHermesConfig(configPath, nextConfig, opts);
+  return configPath;
+}
+
+function installHermesSkills(opts) {
+  const root = hermesSkillsRoot(opts);
+  for (const skill of hermesSkillDefinitions()) {
+    const skillRoot = join(root, skill.dir);
+    writeFile(join(skillRoot, "SKILL.md"), skill.skillMd, opts);
+    if (skill.soulMd) {
+      writeFile(join(skillRoot, "SOUL.md"), skill.soulMd, opts);
+    }
+  }
+  return root;
+}
+
+function installHermes(opts) {
+  // Parse config before writing skills so invalid user YAML cannot leave a
+  // half-installed Hermes skill tree behind.
+  readHermesConfig(opts);
+  let skillsRoot = null;
+  try {
+    skillsRoot = installHermesSkills(opts);
+    const configPath = writeHermesMcpServer(opts);
+    logVerbose(`${C.grey}+ Hermes config updated: ${configPath}${C.reset}`);
+    return { installed: true, configPath, skillsRoot };
+  } catch (err) {
+    if (skillsRoot && !opts.dryRun) {
+      rmSync(skillsRoot, { recursive: true, force: true });
+    }
+    throw err;
+  }
+}
+
+function parseHermesProfileBootstrapArgs(argv) {
+  const opts = {
+    profile: "",
+    profileRoot: "",
+    profilesRoot: "",
+    workspaceId: "",
+    workspaceName: "",
+    token: "",
+    tokenFile: "",
+    apiUrl: process.env.SELLABLE_API_URL || DEFAULT_API_URL,
+    slackBotToken: process.env.SLACK_BOT_TOKEN || "",
+    slackAppToken: process.env.SLACK_APP_TOKEN || "",
+    server: process.env.SELLABLE_INSTALL_SERVER || "package",
+    mcpPackage: DEFAULT_SERVER_PACKAGE,
+    localCommand: process.env.SELLABLE_MCP_LOCAL_COMMAND || "",
+    dryRun: false,
+    json: false,
+    force: false,
+    overwriteEnv: false,
+    allowDuplicateSlackTokens: false,
+    verbose: false,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    const next = () => {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) {
+        throw new Error(`Missing value for ${arg}`);
+      }
+      i += 1;
+      return value;
+    };
+
+    if (arg === "--profile") opts.profile = next();
+    else if (arg === "--profile-root") opts.profileRoot = next();
+    else if (arg === "--profiles-root") opts.profilesRoot = next();
+    else if (arg === "--workspace-id") opts.workspaceId = next();
+    else if (arg === "--workspace-name") opts.workspaceName = next();
+    else if (arg === "--token") opts.token = next();
+    else if (arg === "--token-file") opts.tokenFile = next();
+    else if (arg === "--api-url") opts.apiUrl = next();
+    else if (arg === "--slack-bot-token") opts.slackBotToken = next();
+    else if (arg === "--slack-app-token") opts.slackAppToken = next();
+    else if (arg === "--server") opts.server = next();
+    else if (arg === "--mcp-package") {
+      opts.mcpPackage = normalizeWindowsPackageSpec(next());
+    } else if (arg === "--local-command") opts.localCommand = next();
+    else if (arg === "--dry-run") opts.dryRun = true;
+    else if (arg === "--json") opts.json = true;
+    else if (arg === "--force") opts.force = true;
+    else if (arg === "--overwrite-env") opts.overwriteEnv = true;
+    else if (arg === "--allow-duplicate-slack-tokens") {
+      opts.allowDuplicateSlackTokens = true;
+    } else if (arg === "--verbose") opts.verbose = true;
+    else {
+      throw new Error(`Unknown hermes profile bootstrap option: ${arg}`);
+    }
+  }
+
+  if (!["package", "local"].includes(opts.server)) {
+    throw new Error("hermes profile bootstrap supports --server package or local");
+  }
+  return opts;
+}
+
+function assertSafeProfileName(profile) {
+  if (!profile) return;
+  if (profile.includes("/") || profile.includes("\\") || profile === "." || profile === "..") {
+    throw new Error("--profile must be a profile name, not a path");
+  }
+}
+
+function resolveHermesProfileRoot(opts) {
+  if (opts.profileRoot) {
+    return normalizeOptionalPath(opts.profileRoot);
+  }
+
+  if (opts.profilesRoot || opts.profile) {
+    if (!opts.profilesRoot || !opts.profile) {
+      throw new Error("--profiles-root requires --profile for Hermes bootstrap");
+    }
+    assertSafeProfileName(opts.profile);
+    return join(normalizeOptionalPath(opts.profilesRoot), opts.profile);
+  }
+
+  const envHermesHome = process.env.HERMES_HOME?.trim();
+  if (envHermesHome) {
+    return resolve(envHermesHome);
+  }
+
+  throw new Error(
+    "Missing Hermes profile root. Pass --profile-root, or --profiles-root with --profile, or set HERMES_HOME."
+  );
+}
+
+function readBootstrapToken(opts) {
+  if (opts.tokenFile) {
+    const tokenPath = normalizeOptionalPath(opts.tokenFile);
+    if (!existsSync(tokenPath)) {
+      throw new Error(`Token file not found: ${tokenPath}`);
+    }
+    return {
+      token: readFileSync(tokenPath, "utf8").trim(),
+      source: "token-file",
+    };
+  }
+
+  const envToken = process.env.SELLABLE_API_TOKEN || process.env.SELLABLE_TOKEN || "";
+  if (envToken) return { token: envToken.trim(), source: "env" };
+  if (opts.token) return { token: opts.token.trim(), source: "flag" };
+  return { token: "", source: "none" };
+}
+
+function tokenFingerprint(value) {
+  if (!value) return null;
+  return createHash("sha256").update(value).digest("hex").slice(0, 16);
+}
+
+function parseEnvLines(raw) {
+  const entries = new Map();
+  const passthrough = [];
+  for (const line of String(raw || "").split(/\r?\n/)) {
+    if (!line) continue;
+    const match = line.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+    if (!match) {
+      passthrough.push(line);
+      continue;
+    }
+    entries.set(match[1], match[2]);
+  }
+  return { entries, passthrough };
+}
+
+function renderEnvFile({ entries, passthrough }) {
+  const lines = [...passthrough];
+  for (const [key, value] of entries.entries()) {
+    if (String(value).includes("\n")) {
+      throw new Error(`Invalid newline in ${key}`);
+    }
+    lines.push(`${key}=${value}`);
+  }
+  return `${lines.join("\n")}${lines.length ? "\n" : ""}`;
+}
+
+function findDuplicateSlackTokenProfiles(profileRoot, slackTokens) {
+  const duplicates = [];
+  const profilesRoot = dirname(profileRoot);
+  if (!existsSync(profilesRoot)) return duplicates;
+
+  const requested = Object.entries(slackTokens)
+    .filter(([, value]) => value)
+    .map(([key, value]) => [key, tokenFingerprint(value), value]);
+  if (requested.length === 0) return duplicates;
+
+  for (const name of readdirSync(profilesRoot)) {
+    const siblingRoot = join(profilesRoot, name);
+    if (resolve(siblingRoot) === resolve(profileRoot)) continue;
+    const envPath = join(siblingRoot, ".env");
+    if (!existsSync(envPath)) continue;
+    const existing = parseEnvLines(readFileSync(envPath, "utf8")).entries;
+    for (const [key, fingerprint, rawValue] of requested) {
+      if (existing.get(key) === rawValue) {
+        duplicates.push({ key, fingerprint, profileRoot: siblingRoot });
+      }
+    }
+  }
+  return duplicates;
+}
+
+function readJsonFile(path) {
+  if (!existsSync(path)) return {};
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf8"));
+    return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+  } catch (err) {
+    throw new Error(
+      `Invalid JSON in ${path}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+
+function writeHermesProfileSellableConfig(configPath, raw, opts) {
+  writeJson(configPath, raw, opts);
+}
+
+function runHermesProfileBootstrap(argv) {
+  const parsed = parseHermesProfileBootstrapArgs(argv);
+  const previousVerbose = VERBOSE;
+  VERBOSE = Boolean(parsed.verbose);
+  try {
+    const profileRoot = resolveHermesProfileRoot(parsed);
+    const profile = parsed.profile || basenameSafe(profileRoot);
+    const sellableConfigPath = join(profileRoot, "sellable", "config.json");
+    const sellableConfigsDir = join(profileRoot, "sellable", "configs");
+    const envPath = join(profileRoot, ".env");
+    const { token, source: tokenSource } = readBootstrapToken(parsed);
+    const slackTokens = {
+      SLACK_BOT_TOKEN: parsed.slackBotToken.trim(),
+      SLACK_APP_TOKEN: parsed.slackAppToken.trim(),
+    };
+    const opts = {
+      ...parsed,
+      host: "hermes",
+      hermesHome: profileRoot,
+      sellableConfigPath,
+      sellableConfigsDir,
+      token,
+      tokenSource,
+      workspaceId: parsed.workspaceId,
+      apiUrl: parsed.apiUrl,
+    };
+
+    if (token && !parsed.workspaceId) {
+      throw new Error("--workspace-id is required when a Sellable token is supplied");
+    }
+
+    const summary = {
+      ok: true,
+      command: "hermes profile bootstrap",
+      profile,
+      dryRun: opts.dryRun,
+      paths: {
+        profileRoot,
+        hermesConfigPath: hermesConfigPath(opts),
+        envPath,
+        sellableConfigPath,
+        sellableConfigsDir,
+        skillsRoot: hermesSkillsRoot(opts),
+      },
+      auth: {
+        apiUrl: opts.apiUrl,
+        activeWorkspaceId: parsed.workspaceId || null,
+        activeWorkspaceName: parsed.workspaceName || null,
+        tokenPresent: Boolean(token),
+        tokenSource,
+        tokenFingerprint: tokenFingerprint(token),
+      },
+      slack: {
+        keys: Object.entries(slackTokens)
+          .filter(([, value]) => value)
+          .map(([key]) => key),
+        fingerprints: Object.fromEntries(
+          Object.entries(slackTokens)
+            .filter(([, value]) => value)
+            .map(([key, value]) => [key, tokenFingerprint(value)])
+        ),
+      },
+      created: [],
+      updated: [],
+      preserved: [],
+      skipped: [],
+      warnings: [],
+    };
+
+    let hermesConfig = {};
+    try {
+      hermesConfig = readHermesConfig(opts).config;
+    } catch (err) {
+      throw err;
+    }
+    const existingSellablePath =
+      hermesConfig?.mcp_servers?.sellable?.env?.SELLABLE_CONFIG_PATH || "";
+    if (
+      existingSellablePath &&
+      resolve(existingSellablePath) !== sellableConfigPath &&
+      !opts.force
+    ) {
+      throw new Error(
+        `Existing Hermes sellable MCP points at ${existingSellablePath}; pass --force to replace it with ${sellableConfigPath}.`
+      );
+    }
+
+    const existingAuth = readJsonFile(sellableConfigPath);
+    const existingWorkspaceId =
+      existingAuth.activeWorkspaceId || existingAuth.workspaceId || "";
+    if (
+      existingWorkspaceId &&
+      parsed.workspaceId &&
+      existingWorkspaceId !== parsed.workspaceId &&
+      !opts.force
+    ) {
+      throw new Error(
+        `Existing Sellable profile config uses workspace ${existingWorkspaceId}; pass --force to replace it with ${parsed.workspaceId}.`
+      );
+    }
+
+    let envState = { entries: new Map(), passthrough: [] };
+    if (existsSync(envPath)) {
+      envState = parseEnvLines(readFileSync(envPath, "utf8"));
+    }
+    for (const [key, value] of Object.entries(slackTokens)) {
+      if (!value) continue;
+      const existing = envState.entries.get(key);
+      if (existing && existing !== value && !opts.overwriteEnv) {
+        throw new Error(
+          `${envPath} already has ${key}; pass --overwrite-env to replace it.`
+        );
+      }
+    }
+    if (!opts.allowDuplicateSlackTokens) {
+      const duplicates = findDuplicateSlackTokenProfiles(profileRoot, slackTokens);
+      if (duplicates.length > 0) {
+        const rendered = duplicates
+          .map((dup) => `${dup.key} fingerprint ${dup.fingerprint} in ${dup.profileRoot}`)
+          .join("; ");
+        throw new Error(
+          `Duplicate Slack token detected across Hermes profiles: ${rendered}. Pass --allow-duplicate-slack-tokens to allow this.`
+        );
+      }
+    }
+
+    const hermesConfigExisted = existsSync(hermesConfigPath(opts));
+    const skillsExisted = existsSync(hermesSkillsRoot(opts));
+    const authExisted = existsSync(sellableConfigPath);
+    const configsDirExisted = existsSync(sellableConfigsDir);
+    const envExisted = existsSync(envPath);
+
+    const nextAuth = {
+      ...existingAuth,
+      apiUrl: opts.apiUrl,
+      bootstrap: {
+        ...(existingAuth.bootstrap &&
+        typeof existingAuth.bootstrap === "object" &&
+        !Array.isArray(existingAuth.bootstrap)
+          ? existingAuth.bootstrap
+          : {}),
+        profile,
+        status: token ? "ready" : "pending_auth",
+        updatedAt: new Date().toISOString(),
+      },
+    };
+    if (parsed.workspaceId) {
+      nextAuth.activeWorkspaceId = parsed.workspaceId;
+      nextAuth.workspaceId = parsed.workspaceId;
+    }
+    if (parsed.workspaceName) {
+      nextAuth.activeWorkspaceName = parsed.workspaceName;
+      nextAuth.workspaceName = parsed.workspaceName;
+    }
+    if (token) {
+      nextAuth.token = token;
+    } else if (!existingAuth.token) {
+      delete nextAuth.token;
+    }
+
+    if (!opts.dryRun) {
+      mkdirSync(profileRoot, { recursive: true, mode: 0o700 });
+      mkdirSync(sellableConfigsDir, { recursive: true, mode: 0o700 });
+      writeHermesProfileSellableConfig(sellableConfigPath, nextAuth, opts);
+      installHermes(opts);
+      if (Object.values(slackTokens).some(Boolean)) {
+        for (const [key, value] of Object.entries(slackTokens)) {
+          if (value) envState.entries.set(key, value);
+        }
+        writeFile(envPath, renderEnvFile(envState), opts, 0o600);
+      }
+    }
+
+    (configsDirExisted ? summary.preserved : summary.created).push(
+      sellableConfigsDir
+    );
+    (authExisted ? summary.updated : summary.created).push(sellableConfigPath);
+    (hermesConfigExisted ? summary.updated : summary.created).push(
+      hermesConfigPath(opts)
+    );
+    (skillsExisted ? summary.updated : summary.created).push(hermesSkillsRoot(opts));
+    if (Object.values(slackTokens).some(Boolean)) {
+      (envExisted ? summary.updated : summary.created).push(envPath);
+    } else {
+      summary.skipped.push("Slack env: no Slack tokens supplied");
+    }
+    if (!token) {
+      summary.warnings.push(
+        `Manual auth pending. Run: sellable auth set <token> --workspace-id <workspace_id> --sellable-config-path ${sellableConfigPath}`
+      );
+    }
+
+    if (opts.json) {
+      console.log(JSON.stringify(summary, null, 2));
+    } else {
+      logMilestone(`Hermes profile bootstrapped at ${profileRoot}`);
+      logStep(`Sellable config: ${sellableConfigPath}`);
+      logStep(`Sellable configs dir: ${sellableConfigsDir}`);
+      if (!token) logWarn(summary.warnings[0]);
+    }
+    return summary;
+  } finally {
+    VERBOSE = previousVerbose;
+  }
+}
+
+function basenameSafe(pathValue) {
+  const normalized = resolve(pathValue);
+  return normalized.split(/[\\/]/).filter(Boolean).pop() || "hermes-profile";
+}
+
+function hermesMcpServerMatches(config, opts) {
+  const server = config?.mcp_servers?.sellable;
+  if (!server || typeof server !== "object") return false;
+  const expected = hermesMcpServer(opts);
+  return JSON.stringify(server) === JSON.stringify(expected);
+}
+
+function hermesSkillChecks() {
+  const root = hermesSkillsRoot();
+  const skills = hermesSkillDefinitions();
+  const paths = skills.map((skill) => join(root, skill.dir, "SKILL.md"));
+  const allPresent = paths.every((skillPath) => existsSync(skillPath));
+  const contents = paths
+    .filter((skillPath) => existsSync(skillPath))
+    .map((skillPath) => readFileSync(skillPath, "utf8"));
+  const commandNamesCurrent =
+    contents.length === skills.length &&
+    skills.every((skill, index) =>
+      contents[index]?.includes(`name: ${hermesCommandName(skill.commandName)}`)
+    );
+  const slashCommandsCurrent =
+    contents.length === skills.length &&
+    skills.every((skill, index) =>
+      contents[index]?.includes(`/${hermesCommandName(skill.commandName)}`)
+    );
+  const forbiddenSyntax = contents.some((content) =>
+    /\$sellable:|\/sellable:|mcp__sellable__|request_user_input|AskUserQuestion/.test(
+      content
+    )
+  );
+  return {
+    root,
+    paths,
+    allPresent,
+    commandNamesCurrent,
+    slashCommandsCurrent,
+    forbiddenSyntax,
+  };
+}
+
 function installClaude(opts) {
   if (!commandExists("claude")) {
     const message =
@@ -3356,7 +4287,7 @@ function canonicalClaudeMcpServer(opts) {
     type: "stdio",
     command,
     args,
-    env: { SELLABLE_WATCH_MODE_DRIVER: "claude" },
+    env: mcpEnvForHost("claude", opts),
     alwaysLoad: true,
   };
 }
@@ -3385,7 +4316,7 @@ function claudeMcpServerMatches(server, canonical) {
     server.type === canonical.type &&
     server.command === canonical.command &&
     JSON.stringify(server.args || []) === JSON.stringify(canonical.args) &&
-    server.env?.SELLABLE_WATCH_MODE_DRIVER === "claude"
+    JSON.stringify(server.env || {}) === JSON.stringify(canonical.env)
   );
 }
 
@@ -3444,12 +4375,10 @@ function patchClaudeAlwaysLoad(opts) {
           server.args = [...canonical.args];
           touched = true;
         }
-        const existingDriver = server.env?.SELLABLE_WATCH_MODE_DRIVER;
-        server.env = {
-          ...(server.env && typeof server.env === "object" ? server.env : {}),
-          SELLABLE_WATCH_MODE_DRIVER: "claude",
-        };
-        if (existingDriver !== "claude") {
+        const existingEnv =
+          server.env && typeof server.env === "object" ? server.env : {};
+        server.env = { ...canonical.env };
+        if (JSON.stringify(existingEnv) !== JSON.stringify(server.env)) {
           touched = true;
         }
       }
@@ -3558,9 +4487,16 @@ function warningCheck(ok, label) {
   return { ok, label, required: false };
 }
 
+function firstRunCommandForHost(host) {
+  if (host === "hermes") return "/sellable-create-campaign";
+  if (host === "codex") return "$sellable:create-campaign";
+  if (host === "claude") return "/sellable:create-campaign";
+  return "/sellable:create-campaign, $sellable:create-campaign, or /sellable-create-campaign";
+}
+
 async function verify(opts) {
   const startedAt = new Date().toISOString();
-  const stored = readStoredAuth();
+  const stored = readStoredAuth(opts);
   const checks = [];
   const hasWatchModeDriverMarker = (content, driver) =>
     new RegExp(`SELLABLE_WATCH_MODE_DRIVER[\\s\\S]{0,80}${driver}`).test(
@@ -3568,12 +4504,12 @@ async function verify(opts) {
     ) || new RegExp(`[?&]driver=${driver}(?:\\b|&)`).test(content);
 
   if (stored?.token && stored?.workspaceId) {
-    checks.push(warningCheck(true, `Auth config: ${authPath()}`));
+    checks.push(warningCheck(true, `Auth config: ${authPath(opts)}`));
   } else {
     checks.push(
       warningCheck(
         true,
-        `Auth: not yet signed in — sign in on first run of /sellable:create-campaign`
+        `Auth: not yet signed in — sign in on first run of ${firstRunCommandForHost(opts.host)}`
       )
     );
   }
@@ -3860,6 +4796,88 @@ async function verify(opts) {
       )
     );
   }
+  if (opts.host === "hermes" || opts.host === "all") {
+    let hermesConfig = null;
+    let hermesConfigError = "";
+    try {
+      hermesConfig = readHermesConfig().config;
+    } catch (err) {
+      hermesConfigError = err instanceof Error ? err.message : String(err);
+    }
+    const npmPresent = opts.server !== "package" || commandExists(packageManagerCommand());
+    const skillChecks = hermesSkillChecks();
+    const configMatches = hermesConfig
+      ? hermesMcpServerMatches(hermesConfig, opts)
+      : false;
+    const hasHermesDriver =
+      hermesConfig?.mcp_servers?.sellable?.env?.SELLABLE_WATCH_MODE_DRIVER ===
+      "hermes";
+
+    const check =
+      opts.host === "hermes" ? requiredCheck : warningCheck;
+    checks.push(
+      check(
+        !hermesConfigError,
+        hermesConfigError || `Hermes config readable: ${hermesConfigPath()}`
+      )
+    );
+    checks.push(
+      check(
+        configMatches,
+        configMatches
+          ? "Hermes Sellable MCP entry canonical"
+          : "Hermes Sellable MCP entry missing or stale"
+      )
+    );
+    checks.push(
+      check(
+        hasHermesDriver,
+        hasHermesDriver
+          ? "Hermes watch mode driver pinned to hermes"
+          : "Hermes watch mode driver missing"
+      )
+    );
+    checks.push(
+      check(
+        skillChecks.allPresent,
+        skillChecks.allPresent
+          ? "Hermes Sellable skills present"
+          : "Hermes Sellable skills missing"
+      )
+    );
+    checks.push(
+      check(
+        skillChecks.commandNamesCurrent,
+        skillChecks.commandNamesCurrent
+          ? "Hermes skill names current"
+          : "Hermes skill names stale"
+      )
+    );
+    checks.push(
+      check(
+        skillChecks.slashCommandsCurrent,
+        skillChecks.slashCommandsCurrent
+          ? "Hermes slash command hints current"
+          : "Hermes slash command hints stale"
+      )
+    );
+    checks.push(
+      check(
+        !skillChecks.forbiddenSyntax,
+        !skillChecks.forbiddenSyntax
+          ? "Hermes skills use Hermes MCP/tool syntax"
+          : "Hermes skills contain Claude/Codex-only syntax"
+      )
+    );
+    checks.push(
+      check(
+        npmPresent,
+        npmPresent
+          ? "Hermes package runtime command present"
+          : `Hermes package runtime command missing: ${packageManagerCommand()}`
+      )
+    );
+  }
 
   let runtimeMcp;
   try {
@@ -3870,6 +4888,7 @@ async function verify(opts) {
       cwd: process.cwd(),
       env: {
         ...process.env,
+        ...runtimeMcpEnvForVerify(opts),
         SELLABLE_API_URL: opts.apiUrl,
         SELLABLE_TOKEN: opts.token || process.env.SELLABLE_TOKEN || "",
         SELLABLE_WORKSPACE_ID:
@@ -3925,6 +4944,11 @@ async function verify(opts) {
       install: INSTALL_PACKAGE_SPEC,
       mcp: opts.mcpPackage,
     },
+    sellableConfig: {
+      path: authPath(opts),
+      explicitPath: opts.sellableConfigPath || null,
+      configsDir: opts.sellableConfigsDir || null,
+    },
     checks,
     runtimeMcp,
     threadExposureNotice:
@@ -4042,7 +5066,7 @@ function printNextSteps(installedHosts, authReused) {
       `      ${C.bold}Almost there — install an agent first.${C.reset}`
     );
     console.log(
-      `        ${C.yellow}!${C.reset} No agent CLI found (Claude Code or Codex)`
+      `        ${C.yellow}!${C.reset} No agent CLI/profile found (Claude Code, Codex, or Hermes)`
     );
     console.log("");
     console.log("");
@@ -4086,6 +5110,7 @@ function printNextSteps(installedHosts, authReused) {
 
   const hasClaude = installedHosts.includes("Claude Code");
   const hasCodex = installedHosts.includes("Codex");
+  const hasHermes = installedHosts.includes("Hermes");
 
   // Header
   if (authReused) {
@@ -4101,6 +5126,11 @@ function printNextSteps(installedHosts, authReused) {
     console.log(`        ${C.green}✓${C.reset} Skills installed`);
     console.log(`        ${C.green}✓${C.reset} Codex custom agents installed`);
   }
+  if (hasHermes) {
+    console.log(
+      `        ${C.green}✓${C.reset} Hermes skills and MCP config installed`
+    );
+  }
   if (hasClaude) {
     console.log(
       `        ${C.green}✓${C.reset} Claude slash commands and custom agents installed`
@@ -4144,6 +5174,19 @@ function printNextSteps(installedHosts, authReused) {
     ]);
     console.log("");
   }
+  if (hasHermes) {
+    printAgentBox("Using Hermes?", "hermes", [
+      { label: "Campaign", command: "/sellable-create-campaign" },
+      { label: "A/B Test", command: "/sellable-create-ab-test" },
+      { label: "Evergreen", command: "/sellable-create-evergreen-campaigns" },
+      { label: "Foundation", command: "/sellable-foundation" },
+      { label: "Content", command: "/sellable-content" },
+      { label: "Post", command: "/sellable-create-post" },
+      { label: "Refresh", command: "/sellable-refresh-sender-engagement" },
+      { label: "Refill", command: "/sellable-refill-sends" },
+    ]);
+    console.log("");
+  }
 
   console.log("");
   console.log(`   ${"─".repeat(63)}`);
@@ -4173,7 +5216,7 @@ function removeTomlSection(content, header) {
   return content.replace(pattern, "");
 }
 
-function runUninstall() {
+function runUninstall(opts = { host: "all" }) {
   console.log("");
   console.log(`  ${C.bold}Uninstalling Sellable…${C.reset}`);
   console.log("");
@@ -4184,7 +5227,7 @@ function runUninstall() {
 
   // 1) Surgical removal from Codex config.toml
   const codexConfigPath = join(codexHome(), "config.toml");
-  if (existsSync(codexConfigPath)) {
+  if ((opts.host === "codex" || opts.host === "all") && existsSync(codexConfigPath)) {
     try {
       const before = readFileSync(codexConfigPath, "utf8");
       const ts = new Date()
@@ -4221,10 +5264,11 @@ function runUninstall() {
         `  ${C.yellow}!${C.reset} Could not edit Codex config: ${err instanceof Error ? err.message : String(err)}`
       );
     }
-  } else {
+  } else if (opts.host === "codex" || opts.host === "all") {
     skipped.push(`Codex config not found at ${codexConfigPath}`);
   }
 
+  if (opts.host === "codex" || opts.host === "all") {
   for (const agent of [...codexCustomAgents(), ...legacyCodexCustomAgents()]) {
     const agentPath = join(codexHome(), "agents", agent.filename);
     if (!existsSync(agentPath)) continue;
@@ -4237,9 +5281,10 @@ function runUninstall() {
       );
     }
   }
+  }
 
   // 2) Claude Code MCP removal
-  if (commandExists("claude")) {
+  if ((opts.host === "claude" || opts.host === "all") && commandExists("claude")) {
     const r = spawnSync("claude", ["mcp", "remove", "sellable"], {
       encoding: "utf8",
     });
@@ -4248,10 +5293,11 @@ function runUninstall() {
     } else {
       skipped.push(`Claude Code MCP (none registered or already removed)`);
     }
-  } else {
+  } else if (opts.host === "claude" || opts.host === "all") {
     skipped.push(`Claude Code CLI not found`);
   }
 
+  if (opts.host === "claude" || opts.host === "all") {
   for (const agent of [
     ...claudeCustomAgents(),
     ...legacyClaudeCustomAgents(),
@@ -4279,10 +5325,66 @@ function runUninstall() {
       );
     }
   }
+  }
+
+  // 3) Hermes config and skill removal
+  if (opts.host === "hermes" || opts.host === "all") {
+    const configPath = hermesConfigPath();
+    if (existsSync(configPath)) {
+      try {
+        const before = readFileSync(configPath, "utf8");
+        const ts = new Date()
+          .toISOString()
+          .replace(/[-:]/g, "")
+          .replace(/\..+/, "");
+        const backupPath = `${configPath}.bak-sellable-uninstall-${ts}`;
+        writeFileSync(backupPath, before, { mode: 0o600 });
+        const config = parseHermesConfig(before, configPath);
+        if (
+          config.mcp_servers &&
+          typeof config.mcp_servers === "object" &&
+          !Array.isArray(config.mcp_servers) &&
+          "sellable" in config.mcp_servers
+        ) {
+          const nextMcpServers = { ...config.mcp_servers };
+          delete nextMcpServers.sellable;
+          writeHermesConfig(
+            configPath,
+            { ...config, mcp_servers: nextMcpServers },
+            { dryRun: false }
+          );
+          removed.push(`Hermes config (sellable removed in ${configPath})`);
+          removed.push(`  backup: ${backupPath}`);
+        } else {
+          skipped.push(`Hermes config had no sellable MCP server`);
+        }
+      } catch (err) {
+        console.log(
+          `  ${C.yellow}!${C.reset} Could not edit Hermes config: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    } else {
+      skipped.push(`Hermes config not found at ${configPath}`);
+    }
+
+    const skillsRoot = hermesSkillsRoot();
+    if (existsSync(skillsRoot)) {
+      try {
+        rmSync(skillsRoot, { recursive: true, force: true });
+        removed.push(`${skillsRoot}`);
+      } catch (err) {
+        console.log(
+          `  ${C.yellow}!${C.reset} Could not remove ${skillsRoot}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    } else {
+      skipped.push(`Hermes Sellable skills not found at ${skillsRoot}`);
+    }
+  }
 
-  // 3) Surgical removal of Sellable-installed artifacts inside ~/.sellable/
+  // 4) Surgical removal of Sellable-installed artifacts inside ~/.sellable/
   const sellableDir = join(homedir(), ".sellable");
-  if (existsSync(sellableDir)) {
+  if (opts.host === "all" && existsSync(sellableDir)) {
     const tracked = [
       "config.json",
       "update-check.json",
@@ -4321,13 +5423,13 @@ function runUninstall() {
         // ignore
       }
     }
-  } else {
+  } else if (opts.host === "all") {
     skipped.push(`~/.sellable not present`);
   }
 
-  // 4) Self-shim
+  // 5) Self-shim
   const shimPath = join(homedir(), ".local", "bin", "sellable");
-  if (existsSync(shimPath)) {
+  if (opts.host === "all" && existsSync(shimPath)) {
     try {
       rmSync(shimPath, { force: true });
       removed.push(`${shimPath}`);
@@ -4375,6 +5477,7 @@ async function main() {
       const authSetFlags = rawArgs.slice(3);
       let dryRun = false;
       let workspaceId = "";
+      let sellableConfigPath = process.env.SELLABLE_CONFIG_PATH || "";
       for (let i = 0; i < authSetFlags.length; i += 1) {
         const flag = authSetFlags[i];
         if (flag === "--dry-run") {
@@ -4391,6 +5494,16 @@ async function main() {
           i += 1;
           continue;
         }
+        if (flag === "--sellable-config-path") {
+          const value = authSetFlags[i + 1];
+          if (!value || value.startsWith("--")) {
+            console.error("Missing value for --sellable-config-path");
+            process.exit(2);
+          }
+          sellableConfigPath = value;
+          i += 1;
+          continue;
+        }
         console.error(`Unknown auth set option: ${flag}`);
         process.exit(2);
       }
@@ -4415,11 +5528,18 @@ async function main() {
       // Skip installSelfShim() — by definition the user has the shim already
       // (they invoked `sellable auth set` from it).
       const apiUrl = process.env.SELLABLE_API_URL || DEFAULT_API_URL;
-      writeAuthSetConfig({ token, workspaceId, apiUrl, dryRun });
+      writeAuthSetConfig({
+        token,
+        workspaceId,
+        apiUrl,
+        dryRun,
+        sellableConfigPath,
+      });
+      const configPath = authPath({ sellableConfigPath });
       if (dryRun) {
-        console.log(`Dry run: token would be saved to ${authPath()}`);
+        console.log(`Dry run: token would be saved to ${configPath}`);
       } else {
-        console.log(`✓ Token saved to ${authPath()}`);
+        console.log(`✓ Token saved to ${configPath}`);
       }
       console.log(`  apiUrl: ${apiUrl}`);
       if (workspaceId) {
@@ -4440,6 +5560,13 @@ async function main() {
       console.log(`    Codex: $sellable:create-post`);
       console.log(`    Codex: $sellable:refresh-sender-engagement`);
       console.log(`    Codex: $sellable:refill-sends`);
+      console.log(`    Hermes: /sellable-create-campaign`);
+      console.log(`    Hermes: /sellable-create-evergreen-campaigns`);
+      console.log(`    Hermes: /sellable-foundation`);
+      console.log(`    Hermes: /sellable-content`);
+      console.log(`    Hermes: /sellable-create-post`);
+      console.log(`    Hermes: /sellable-refresh-sender-engagement`);
+      console.log(`    Hermes: /sellable-refill-sends`);
       process.exit(0);
     }
     if (rawArgs[0] === "prefs") {
@@ -4482,13 +5609,22 @@ async function main() {
       process.exit(0);
     }
     if (rawArgs[0] === "uninstall") {
-      runUninstall();
+      const opts = parseArgs(rawArgs.slice(1));
+      runUninstall(opts);
       process.exit(0);
     }
     if (rawArgs[0] === "create") {
       printCreateCommandHint();
       process.exit(0);
     }
+    if (
+      rawArgs[0] === "hermes" &&
+      rawArgs[1] === "profile" &&
+      rawArgs[2] === "bootstrap"
+    ) {
+      runHermesProfileBootstrap(rawArgs.slice(3));
+      process.exit(0);
+    }
     const opts = parseArgs(process.argv.slice(2));
     if (opts.help) {
       console.log(usage());
@@ -4500,7 +5636,7 @@ async function main() {
     if (!opts.verifyOnly) {
       printBanner();
       console.log(
-        `  ${C.bold}Connecting Sellable to Claude Code and Codex…${C.reset}`
+        `  ${C.bold}Connecting Sellable to Claude Code, Codex, and Hermes…${C.reset}`
       );
       console.log("");
     } else if (!opts.json) {
@@ -4536,6 +5672,15 @@ async function main() {
           installedHosts.push("Codex");
         }
       }
+      if (
+        opts.host === "hermes" ||
+        (opts.host === "all" && hermesLikelyInstalled())
+      ) {
+        const result = installHermes(opts);
+        if (result.installed) {
+          installedHosts.push("Hermes");
+        }
+      }
     }
 
     if (opts.dryRun) {