@sellable/install 0.1.311 → 0.1.313

package/README.md

@@ -122,9 +122,6 @@ It creates:
 /srv/hermes/profiles/acme/.env        # only when Slack token inputs are supplied
 ```
 
-See [`HERMES-SLACK-PROFILE-SCOPING.md`](./HERMES-SLACK-PROFILE-SCOPING.md) for
-the customer Slack isolation contract and Socket Mode token requirements.
-
 If no token is supplied, bootstrap still creates a pending
 `sellable/config.json` so the profile path is concrete from the first MCP
 launch. Finish auth with:
@@ -145,36 +142,6 @@ sellable hermes profile bootstrap \
   --slack-app-token "$SLACK_APP_TOKEN"
 ```
 
-The Slack app must also be configured for inbound Socket Mode delivery. Outbound
-Slack Web API sends can work before this is complete, but Hermes will not hear
-mentions until the app has Socket Mode enabled, an app-level token with
-`connections:write`, bot scopes/events for `app_mention` plus channel/group/IM
-message events, and a fresh workspace reinstall after scope or event changes.
-
-Scope the profile to its customer channel at install time:
-
-```bash
-sellable hermes profile bootstrap \
-  --profile acme \
-  --profiles-root /srv/hermes/profiles \
-  --workspace-id ws_acme \
-  --slack-bot-token "$SLACK_BOT_TOKEN" \
-  --slack-app-token "$SLACK_APP_TOKEN" \
-  --slack-home-channel C0ACME12345 \
-  --slack-home-channel-name sellable-acme \
-  --slack-allowed-users U0OPERATOR1 \
-  --slack-require-mention true
-```
-
-When `--slack-home-channel` is supplied without
-`--slack-allowed-channels`, bootstrap writes
-`SLACK_ALLOWED_CHANNELS=<home-channel-id>` too. That fail-closes a customer
-profile to the intended channel by default. Use
-`--slack-allowed-channels C...,G...` only when a profile is deliberately allowed
-to listen in multiple channels. Pass channel IDs, not `#channel-name`, and use
-separate Slack bot/app tokens per customer profile when you need hard isolation
-between concurrently listening Hermes profiles.
-
 Customer profiles should use customer-scoped Sellable credentials. A shared
 Sellable admin token can work for internal admin automation, but it is weaker
 isolation and should not be the default for customer profiles. After changing

package/bin/sellable-install.mjs

@@ -217,11 +217,9 @@ Hermes profile bootstrap:
 
   Bootstrap writes <profileRoot>/config.yaml, <profileRoot>/sellable/config.json,
   <profileRoot>/sellable/configs, Sellable Hermes skills, and optional
-  <profileRoot>/.env Slack token and channel-scope keys. For customer profiles,
-  pass --slack-home-channel; bootstrap defaults SLACK_ALLOWED_CHANNELS to that
-  exact channel id unless --slack-allowed-channels is supplied. Use
-  customer-scoped Sellable and Slack credentials for customer profiles; shared
-  admin tokens are weaker isolation and should remain internal-only.
+  <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.
 `;
 }
 
@@ -3791,12 +3789,6 @@ function parseHermesProfileBootstrapArgs(argv) {
     apiUrl: process.env.SELLABLE_API_URL || DEFAULT_API_URL,
     slackBotToken: process.env.SLACK_BOT_TOKEN || "",
     slackAppToken: process.env.SLACK_APP_TOKEN || "",
-    slackHomeChannel: process.env.SLACK_HOME_CHANNEL || "",
-    slackHomeChannelName: process.env.SLACK_HOME_CHANNEL_NAME || "",
-    slackAllowedChannels: process.env.SLACK_ALLOWED_CHANNELS || "",
-    slackFreeResponseChannels: process.env.SLACK_FREE_RESPONSE_CHANNELS || "",
-    slackAllowedUsers: process.env.SLACK_ALLOWED_USERS || "",
-    slackRequireMention: process.env.SLACK_REQUIRE_MENTION || "",
     server: process.env.SELLABLE_INSTALL_SERVER || "package",
     mcpPackage: DEFAULT_SERVER_PACKAGE,
     localCommand: process.env.SELLABLE_MCP_LOCAL_COMMAND || "",
@@ -3829,12 +3821,6 @@ function parseHermesProfileBootstrapArgs(argv) {
     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 === "--slack-home-channel") opts.slackHomeChannel = next();
-    else if (arg === "--slack-home-channel-name") opts.slackHomeChannelName = next();
-    else if (arg === "--slack-allowed-channels") opts.slackAllowedChannels = next();
-    else if (arg === "--slack-free-response-channels") opts.slackFreeResponseChannels = next();
-    else if (arg === "--slack-allowed-users") opts.slackAllowedUsers = next();
-    else if (arg === "--slack-require-mention") opts.slackRequireMention = next();
     else if (arg === "--server") opts.server = next();
     else if (arg === "--mcp-package") {
       opts.mcpPackage = normalizeWindowsPackageSpec(next());
@@ -3936,111 +3922,6 @@ function renderEnvFile({ entries, passthrough }) {
   return `${lines.join("\n")}${lines.length ? "\n" : ""}`;
 }
 
-function normalizeSlackChannelIds(value, key) {
-  const raw = String(value || "").trim();
-  if (!raw) return "";
-  const ids = raw
-    .split(",")
-    .map((item) => item.trim())
-    .filter(Boolean);
-  if (ids.length === 0) return "";
-
-  for (const id of ids) {
-    if (
-      id === "*" ||
-      /^all$/i.test(id) ||
-      id.startsWith("#") ||
-      /\s/.test(id) ||
-      !/^[A-Z][A-Z0-9]{8,}$/.test(id)
-    ) {
-      throw new Error(
-        `${key} must be comma-separated Slack channel IDs, not names, wildcards, or free text. Bad value: ${id}`
-      );
-    }
-  }
-  return [...new Set(ids)].join(",");
-}
-
-function normalizeSlackSingleChannelId(value, key) {
-  const normalized = normalizeSlackChannelIds(value, key);
-  if (normalized.includes(",")) {
-    throw new Error(`${key} must be a single Slack channel ID`);
-  }
-  return normalized;
-}
-
-function normalizeSlackUserIds(value, key) {
-  const raw = String(value || "").trim();
-  if (!raw) return "";
-  const ids = raw
-    .split(",")
-    .map((item) => item.trim())
-    .filter(Boolean);
-  if (ids.length === 0) return "";
-
-  for (const id of ids) {
-    if (!/^[UW][A-Z0-9]{8,}$/.test(id)) {
-      throw new Error(`${key} must be comma-separated Slack user IDs. Bad value: ${id}`);
-    }
-  }
-  return [...new Set(ids)].join(",");
-}
-
-function normalizeSlackChannelName(value, key) {
-  const raw = String(value || "").trim();
-  if (!raw) return "";
-  if (raw.startsWith("#") || /[\s,]/.test(raw)) {
-    throw new Error(`${key} must be a Slack channel name without #, spaces, or commas`);
-  }
-  return raw;
-}
-
-function normalizeSlackBoolean(value, key) {
-  const raw = String(value || "").trim().toLowerCase();
-  if (!raw) return "";
-  if (raw !== "true" && raw !== "false") {
-    throw new Error(`${key} must be true or false`);
-  }
-  return raw;
-}
-
-function buildSlackProfileEnv(parsed) {
-  const homeChannel = normalizeSlackSingleChannelId(
-    parsed.slackHomeChannel,
-    "SLACK_HOME_CHANNEL"
-  );
-  const explicitAllowedChannels = normalizeSlackChannelIds(
-    parsed.slackAllowedChannels,
-    "SLACK_ALLOWED_CHANNELS"
-  );
-  const allowedChannels = explicitAllowedChannels || homeChannel;
-
-  return {
-    SLACK_BOT_TOKEN: parsed.slackBotToken.trim(),
-    SLACK_APP_TOKEN: parsed.slackAppToken.trim(),
-    SLACK_HOME_CHANNEL: homeChannel,
-    SLACK_HOME_CHANNEL_NAME: normalizeSlackChannelName(
-      parsed.slackHomeChannelName,
-      "SLACK_HOME_CHANNEL_NAME"
-    ),
-    // Customer Hermes profiles must fail closed to their channel. If the caller
-    // supplies only a home channel, we treat that as the allowlist too.
-    SLACK_ALLOWED_CHANNELS: allowedChannels,
-    SLACK_FREE_RESPONSE_CHANNELS: normalizeSlackChannelIds(
-      parsed.slackFreeResponseChannels,
-      "SLACK_FREE_RESPONSE_CHANNELS"
-    ),
-    SLACK_ALLOWED_USERS: normalizeSlackUserIds(
-      parsed.slackAllowedUsers,
-      "SLACK_ALLOWED_USERS"
-    ),
-    SLACK_REQUIRE_MENTION: normalizeSlackBoolean(
-      parsed.slackRequireMention,
-      "SLACK_REQUIRE_MENTION"
-    ),
-  };
-}
-
 function findDuplicateSlackTokenProfiles(profileRoot, slackTokens) {
   const duplicates = [];
   const profilesRoot = dirname(profileRoot);
@@ -4093,14 +3974,10 @@ function runHermesProfileBootstrap(argv) {
     const sellableConfigsDir = join(profileRoot, "sellable", "configs");
     const envPath = join(profileRoot, ".env");
     const { token, source: tokenSource } = readBootstrapToken(parsed);
-    const slackEnv = buildSlackProfileEnv(parsed);
     const slackTokens = {
-      SLACK_BOT_TOKEN: slackEnv.SLACK_BOT_TOKEN,
-      SLACK_APP_TOKEN: slackEnv.SLACK_APP_TOKEN,
+      SLACK_BOT_TOKEN: parsed.slackBotToken.trim(),
+      SLACK_APP_TOKEN: parsed.slackAppToken.trim(),
     };
-    const slackEnvKeys = Object.entries(slackEnv)
-      .filter(([, value]) => value)
-      .map(([key]) => key);
     const opts = {
       ...parsed,
       host: "hermes",
@@ -4142,29 +4019,11 @@ function runHermesProfileBootstrap(argv) {
         keys: Object.entries(slackTokens)
           .filter(([, value]) => value)
           .map(([key]) => key),
-        envKeys: slackEnvKeys,
         fingerprints: Object.fromEntries(
           Object.entries(slackTokens)
             .filter(([, value]) => value)
             .map(([key, value]) => [key, tokenFingerprint(value)])
         ),
-        scope: {
-          homeChannel: slackEnv.SLACK_HOME_CHANNEL || null,
-          homeChannelName: slackEnv.SLACK_HOME_CHANNEL_NAME || null,
-          allowedChannels: slackEnv.SLACK_ALLOWED_CHANNELS
-            ? slackEnv.SLACK_ALLOWED_CHANNELS.split(",")
-            : [],
-          freeResponseChannels: slackEnv.SLACK_FREE_RESPONSE_CHANNELS
-            ? slackEnv.SLACK_FREE_RESPONSE_CHANNELS.split(",")
-            : [],
-          allowedUsersCount: slackEnv.SLACK_ALLOWED_USERS
-            ? slackEnv.SLACK_ALLOWED_USERS.split(",").length
-            : 0,
-          requireMention:
-            slackEnv.SLACK_REQUIRE_MENTION === ""
-              ? null
-              : slackEnv.SLACK_REQUIRE_MENTION === "true",
-        },
       },
       created: [],
       updated: [],
@@ -4209,7 +4068,7 @@ function runHermesProfileBootstrap(argv) {
     if (existsSync(envPath)) {
       envState = parseEnvLines(readFileSync(envPath, "utf8"));
     }
-    for (const [key, value] of Object.entries(slackEnv)) {
+    for (const [key, value] of Object.entries(slackTokens)) {
       if (!value) continue;
       const existing = envState.entries.get(key);
       if (existing && existing !== value && !opts.overwriteEnv) {
@@ -4269,8 +4128,8 @@ function runHermesProfileBootstrap(argv) {
       mkdirSync(sellableConfigsDir, { recursive: true, mode: 0o700 });
       writeHermesProfileSellableConfig(sellableConfigPath, nextAuth, opts);
       installHermes(opts);
-      if (Object.values(slackEnv).some(Boolean)) {
-        for (const [key, value] of Object.entries(slackEnv)) {
+      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);
@@ -4285,20 +4144,10 @@ function runHermesProfileBootstrap(argv) {
       hermesConfigPath(opts)
     );
     (skillsExisted ? summary.updated : summary.created).push(hermesSkillsRoot(opts));
-    if (Object.values(slackEnv).some(Boolean)) {
+    if (Object.values(slackTokens).some(Boolean)) {
       (envExisted ? summary.updated : summary.created).push(envPath);
     } else {
-      summary.skipped.push("Slack env: no Slack tokens or channel scope supplied");
-    }
-    if (slackEnv.SLACK_HOME_CHANNEL && !parsed.slackAllowedChannels.trim()) {
-      summary.warnings.push(
-        "Slack scope defaulted SLACK_ALLOWED_CHANNELS to SLACK_HOME_CHANNEL for fail-closed profile listening."
-      );
-    }
-    if (slackEnv.SLACK_BOT_TOKEN && !slackEnv.SLACK_APP_TOKEN) {
-      summary.warnings.push(
-        "Slack bot token is present without SLACK_APP_TOKEN; outbound Slack sends may work, but native Hermes Socket Mode listening still requires an xapp app-level token with connections:write."
-      );
+      summary.skipped.push("Slack env: no Slack tokens supplied");
     }
     if (!token) {
       summary.warnings.push(

package/lib/runtime-verify.mjs

@@ -45,6 +45,14 @@ export const REQUIRED_SELLABLE_MCP_TOOLS = [
 
 export const FORBIDDEN_SELLABLE_MCP_TOOLS = ["refill_campaign_sends"];
 
+const CONNECTION_ONLY_EVERGREEN_PROMPT_CHUNK_LIMIT = 48_000;
+const CONNECTION_ONLY_EVERGREEN_MAX_PROMPT_CHUNKS = 8;
+const CONNECTION_ONLY_EVERGREEN_PROOF_NEEDLES = {
+  campaignSequenceOptions: 'campaignSequenceOptions:{ mode:"connection_only" }',
+  templateRef: 'templateRef:"connection_only"',
+  sendInviteReceipt: 'sequenceReceipt.actionTypes:["send_invite"]',
+};
+
 export const CREATE_CAMPAIGN_SMOKE_CALLS = [
   {
     name: "get_auth_status",
@@ -84,6 +92,14 @@ export const CREATE_CAMPAIGN_SMOKE_CALLS = [
       limit: 1200,
     },
   },
+  {
+    name: "get_subskill_prompt",
+    arguments: {
+      subskillName: "create-evergreen-campaigns",
+      offset: 0,
+      limit: CONNECTION_ONLY_EVERGREEN_PROMPT_CHUNK_LIMIT,
+    },
+  },
   {
     name: "refill_sends",
     arguments: {
@@ -187,6 +203,43 @@ function parseJsonText(text) {
   }
 }
 
+function emptyConnectionOnlyEvergreenProofs() {
+  return Object.fromEntries(
+    Object.keys(CONNECTION_ONLY_EVERGREEN_PROOF_NEEDLES).map((key) => [
+      key,
+      false,
+    ])
+  );
+}
+
+function getConnectionOnlyEvergreenProofs(prompt) {
+  return Object.fromEntries(
+    Object.entries(CONNECTION_ONLY_EVERGREEN_PROOF_NEEDLES).map(
+      ([key, needle]) => [key, prompt.includes(needle)]
+    )
+  );
+}
+
+function mergeConnectionOnlyEvergreenProofs(target, source) {
+  if (!source) return target;
+  for (const key of Object.keys(CONNECTION_ONLY_EVERGREEN_PROOF_NEEDLES)) {
+    target[key] = target[key] === true || source[key] === true;
+  }
+  return target;
+}
+
+function summarizeConnectionOnlyEvergreenProofs(proofs) {
+  const merged = { ...emptyConnectionOnlyEvergreenProofs(), ...(proofs || {}) };
+  const missing = Object.keys(CONNECTION_ONLY_EVERGREEN_PROOF_NEEDLES).filter(
+    (key) => merged[key] !== true
+  );
+  return {
+    ok: missing.length === 0,
+    proofs: merged,
+    missing,
+  };
+}
+
 function summarizeToolResult(name, result) {
   const text = redact(textFromToolResult(result));
   const parsed = parseJsonText(text);
@@ -230,10 +283,26 @@ function summarizeToolResult(name, result) {
   }
 
   if (name === "get_subskill_prompt" && parsed) {
+    const prompt = typeof parsed.prompt === "string" ? parsed.prompt : "";
+    const connectionOnlyEvergreenProofs =
+      parsed.name === "create-evergreen-campaigns"
+        ? getConnectionOnlyEvergreenProofs(prompt)
+        : null;
     return {
       ...summary,
       subskillName: parsed.name || null,
-      promptChars: typeof parsed.prompt === "string" ? parsed.prompt.length : 0,
+      promptChars: prompt.length,
+      promptLength:
+        typeof parsed.promptLength === "number" ? parsed.promptLength : null,
+      offset: typeof parsed.offset === "number" ? parsed.offset : null,
+      limit: typeof parsed.limit === "number" ? parsed.limit : null,
+      connectionOnlyEvergreenProofs,
+      connectionOnlyEvergreenGuidance:
+        parsed.name === "create-evergreen-campaigns"
+          ? summarizeConnectionOnlyEvergreenProofs(
+              connectionOnlyEvergreenProofs
+            ).ok
+          : null,
       hasMore: parsed.hasMore === true,
       nextOffset:
         typeof parsed.nextOffset === "number" ? parsed.nextOffset : null,
@@ -267,6 +336,7 @@ async function verifyCreateCampaignSmoke({
     .map((call) => call.name)
     .filter((name) => !available.has(name));
   const calls = [];
+  const connectionOnlyEvergreenProofs = emptyConnectionOnlyEvergreenProofs();
 
   if (missingTools.length > 0) {
     return {
@@ -280,67 +350,195 @@ async function verifyCreateCampaignSmoke({
   }
 
   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,
+    let nextCall = call;
+    let evergreenPromptChunks = 0;
+    const evergreenPromptOffsets = new Set();
+
+    while (nextCall) {
+      const callStartedAt = new Date().toISOString();
+      try {
+        const result = await client.callTool(
+          { name: nextCall.name, arguments: nextCall.arguments },
+          undefined,
+          {
+            timeout: timeoutMs,
+            maxTotalTimeout: timeoutMs,
+          }
+        );
+        const summary = summarizeToolResult(nextCall.name, result);
+        calls.push({
+          name: nextCall.name,
+          arguments: nextCall.arguments,
+          ok: summary.isError !== true,
+          summary,
+          startedAt: callStartedAt,
+          completedAt: new Date().toISOString(),
+        });
+        if (summary.isError === true) {
+          return {
+            ok: false,
+            missingTools: [],
+            calls,
+            error: `${nextCall.name} returned an MCP tool error`,
+            startedAt,
+            completedAt: new Date().toISOString(),
+          };
         }
-      );
-      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) {
+
+        const isConnectionOnlyEvergreenPrompt =
+          nextCall.name === "get_subskill_prompt" &&
+          nextCall.arguments?.subskillName === "create-evergreen-campaigns";
+        if (!isConnectionOnlyEvergreenPrompt) {
+          break;
+        }
+
+        evergreenPromptChunks += 1;
+        evergreenPromptOffsets.add(nextCall.arguments?.offset ?? 0);
+        mergeConnectionOnlyEvergreenProofs(
+          connectionOnlyEvergreenProofs,
+          summary.connectionOnlyEvergreenProofs
+        );
+
+        if (summary.hasMore !== true) {
+          break;
+        }
+        if (typeof summary.nextOffset !== "number") {
+          return {
+            ok: false,
+            missingTools: [],
+            calls,
+            connectionOnlyEvergreenGuidance:
+              summarizeConnectionOnlyEvergreenProofs(
+                connectionOnlyEvergreenProofs
+              ),
+            error:
+              "create-evergreen-campaigns prompt chunk is missing nextOffset",
+            startedAt,
+            completedAt: new Date().toISOString(),
+          };
+        }
+        if (evergreenPromptOffsets.has(summary.nextOffset)) {
+          return {
+            ok: false,
+            missingTools: [],
+            calls,
+            connectionOnlyEvergreenGuidance:
+              summarizeConnectionOnlyEvergreenProofs(
+                connectionOnlyEvergreenProofs
+              ),
+            error:
+              "create-evergreen-campaigns prompt chunk repeated nextOffset",
+            startedAt,
+            completedAt: new Date().toISOString(),
+          };
+        }
+        if (
+          evergreenPromptChunks >= CONNECTION_ONLY_EVERGREEN_MAX_PROMPT_CHUNKS
+        ) {
+          return {
+            ok: false,
+            missingTools: [],
+            calls,
+            connectionOnlyEvergreenGuidance:
+              summarizeConnectionOnlyEvergreenProofs(
+                connectionOnlyEvergreenProofs
+              ),
+            error:
+              "create-evergreen-campaigns prompt exceeded smoke chunk limit",
+            startedAt,
+            completedAt: new Date().toISOString(),
+          };
+        }
+
+        nextCall = {
+          ...nextCall,
+          arguments: {
+            ...nextCall.arguments,
+            offset: summary.nextOffset,
+            limit:
+              nextCall.arguments?.limit ||
+              CONNECTION_ONLY_EVERGREEN_PROMPT_CHUNK_LIMIT,
+          },
+        };
+      } catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        calls.push({
+          name: nextCall.name,
+          arguments: nextCall.arguments,
+          ok: false,
+          summary: null,
+          error: redact(error),
+          startedAt: callStartedAt,
+          completedAt: new Date().toISOString(),
+        });
         return {
           ok: false,
           missingTools: [],
           calls,
-          error: `${call.name} returned an MCP tool error`,
+          error: redact(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(),
-      };
     }
   }
 
+  const connectionOnlyEvergreenGuidance =
+    summarizeConnectionOnlyEvergreenProofs(connectionOnlyEvergreenProofs);
+  if (connectionOnlyEvergreenGuidance.ok !== true) {
+    return {
+      ok: false,
+      missingTools: [],
+      calls,
+      connectionOnlyEvergreenGuidance,
+      error: `create-evergreen-campaigns prompt is missing connection-only guidance: ${connectionOnlyEvergreenGuidance.missing.join(", ")}`,
+      startedAt,
+      completedAt: new Date().toISOString(),
+    };
+  }
+
   return {
     ok: true,
     missingTools: [],
     calls,
+    connectionOnlyEvergreenGuidance,
     error: null,
     startedAt,
     completedAt: new Date().toISOString(),
   };
 }
 
+function verifyConnectionOnlyEvergreenContract(tools) {
+  const setupTool = (tools || []).find(
+    (tool) => tool?.name === "setup_evergreen_campaigns"
+  );
+  const schema = setupTool?.inputSchema || {};
+  const properties = schema.properties || {};
+  const sequenceOptions = properties.campaignSequenceOptions || {};
+  const mode = sequenceOptions.properties?.mode || {};
+  const issues = [];
+
+  if (!properties.workspaceId) {
+    issues.push("setup_evergreen_campaigns.workspaceId");
+  }
+  if (!properties.campaignSequenceOptions) {
+    issues.push("setup_evergreen_campaigns.campaignSequenceOptions");
+  }
+  if (!Array.isArray(mode.enum) || !mode.enum.includes("connection_only")) {
+    issues.push("setup_evergreen_campaigns.campaignSequenceOptions.mode");
+  }
+  if (sequenceOptions.additionalProperties !== false) {
+    issues.push(
+      "setup_evergreen_campaigns.campaignSequenceOptions.additionalProperties"
+    );
+  }
+
+  return {
+    ok: issues.length === 0,
+    issues,
+  };
+}
+
 function summarizeAttempt(result, attempt) {
   return {
     attempt,
@@ -348,6 +546,12 @@ function summarizeAttempt(result, attempt) {
     availableToolCount: result.availableTools?.length || 0,
     missingToolCount: result.missingTools?.length || 0,
     forbiddenToolCount: result.forbiddenTools?.length || 0,
+    connectionOnlyEvergreenContract: result.connectionOnlyEvergreenContract
+      ? {
+          ok: result.connectionOnlyEvergreenContract.ok === true,
+          issues: result.connectionOnlyEvergreenContract.issues || [],
+        }
+      : null,
     error: result.error || null,
     createCampaignSmoke: result.createCampaignSmoke
       ? {
@@ -419,6 +623,7 @@ async function verifySellableMcpRuntimeOnce({
   let missingTools = [...requiredTools];
   let forbiddenTools = [];
   let createCampaignSmoke = null;
+  let connectionOnlyEvergreenContract = { ok: false, issues: [] };
   let error = null;
 
   try {
@@ -432,6 +637,8 @@ async function verifySellableMcpRuntimeOnce({
     forbiddenTools = availableTools.filter((tool) =>
       FORBIDDEN_SELLABLE_MCP_TOOLS.includes(tool)
     );
+    connectionOnlyEvergreenContract =
+      verifyConnectionOnlyEvergreenContract(toolList.tools);
     if (forbiddenTools.length > 0) {
       createCampaignSmoke = {
         ok: false,
@@ -475,6 +682,7 @@ async function verifySellableMcpRuntimeOnce({
       !error &&
       missingTools.length === 0 &&
       forbiddenTools.length === 0 &&
+      connectionOnlyEvergreenContract.ok === true &&
       createCampaignSmoke?.ok === true,
     skipped: false,
     command,
@@ -483,6 +691,7 @@ async function verifySellableMcpRuntimeOnce({
     availableTools,
     missingTools,
     forbiddenTools,
+    connectionOnlyEvergreenContract,
     createCampaignSmoke,
     stderrTail: stderrLines,
     error: error ? redact(error) : null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/install",
-  "version": "0.1.311",
+  "version": "0.1.313",
   "type": "module",
   "description": "One-command installer for Sellable MCP in Claude Code, Codex, and Hermes",
   "bin": {
@@ -15,8 +15,7 @@
     "lib",
     "agents",
     "skill-templates",
-    "README.md",
-    "HERMES-SLACK-PROFILE-SCOPING.md"
+    "README.md"
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.2",

package/skill-templates/create-evergreen-campaigns.md

@@ -134,6 +134,18 @@ run without user input, or similar, run in **automation mode**:
     exactly one quality-valid route-proof row when needed, and attach the
     recommended sequence, but it still must not launch campaigns, schedule
     sends, send messages, or spend paid InMail.
+  - **Connection-only evergreen completion is optional and non-default.** Use it
+    only when the prompt explicitly says connection-only, invite-only,
+    connection request only, no DMs, or no follow-ups. Pass the typed option
+    `campaignSequenceOptions:{ mode:"connection_only" }` plus an explicit
+    `workspaceId` to `setup_evergreen_campaigns`. Omit
+    `campaignSequenceOptions` for the standard tier-recommended Premium,
+    Sales Nav, Recruiter, and paid InMail behavior.
+    Connection-only completion still creates/reuses the same evergreen lanes,
+    source rows, and paused/unlaunched review state, but it attaches only the
+    canonical invite template. It does not require Message Drafting, generated
+    messages, route-proof approval, first DM, InMail, View Profile fallback,
+    follow-up branch, `currentStep:"send"`, launch, scheduling, or sends.
 
 If the invoking prompt explicitly asks for interactive message polish or sample
 proof, run in **interactive polish mode** and use the confirmation/sample steps
@@ -720,6 +732,9 @@ not a parent-thread summary. The receipt must include:
   creation, preserve that original packet only in a separate `parentLanePacket`
   object; do not leave `setupPlanCall.campaignId:null` or
   `setupPlanCall.tableId:null`.
+  If the parent plan used connection-only, the receipt must also include
+  `setupPlanCall.campaignSequenceOptions:{ "mode":"connection_only" }` or
+  `setupPlanCall.sequencePolicy.mode:"connection_only"`.
   Short form: For create lanes, `setupPlanCall.campaignId` and `setupPlanCall.tableId` must be the actual created campaign/table ids.
   Short form: Do not leave `setupPlanCall.campaignId:null` or `setupPlanCall.tableId:null`.
 - `createCampaignWorkflowReceipt`: proof the worker loaded the actual installed
@@ -810,21 +825,39 @@ not a parent-thread summary. The receipt must include:
   them into canonical `promptLoadedToHasMoreFalse`, `requiredAssetsLoaded`,
   `validationLoaded`, `reviewBatchRowHash`, and
   `messageDraftRecommendation`.
+  Connection-only lanes are the exception: do not include
+  `messageDraftingReceipt` or run generated-message prep unless the operator
+  separately asked for message copy. The parent verifier expects no message
+  proof for connection-only lanes.
 - `reviewBatchReceipt`: review-batch row ids/hash, generated row count,
   quality-valid route-proof row id when approved, and proof that no broad
   approve-all occurred.
+  Connection-only lanes are the exception: do not approve a route-proof row and
+  do not include a required review-batch receipt.
 - `sequenceReceipt`: exact current workflowTableId, recommended non-paid
   sequence attach/precheck result, and readback showing `hasSequence:true` when
   completion is claimed. If the tool output uses
   `attachRecommendedSequenceResult.actionTypes` or
   `nonPaidRecommendedSequence`, copy them to canonical `actionTypes` and
   `nonPaid`.
+  For connection-only lanes, do not call `attach_recommended_sequence`. Attach
+  with `attach_sequence({ tableId, templateRef:"connection_only" })`, then
+  include exact current-template proof:
+  `sequenceReceipt.hasSequence:true`,
+  `sequenceReceipt.actionTypes:["send_invite"]`, and
+  `sequenceReceipt.nonPaid:true`. Receipts that only say
+  `tool:"attach_recommended_sequence"` or include `send_dm`,
+  `send_inmail_open`, `send_inmail_closed`, or `view_profile` are failing
+  connection-only receipts.
 - final paused-send proof: if the current campaign table is `DRAFT` after the
   sequence is attached, call the product `pause_campaign({ campaignId })`
   endpoint/tool to put the unlaunched campaign into `PAUSED` review state, then
   reread the campaign/table. Do not raw-write `campaignStatus`, do not start or
   launch, and do not schedule/send. Completion requires reread proof of
-  `currentStep:"send"` and `campaignStatus:"PAUSED"`. If the raw output nests
+  `currentStep:"send"` and `campaignStatus:"PAUSED"` for standard
+  customer-visible lanes. Connection-only lanes may finish at a paused
+  unlaunched review step such as `currentStep:"review"` as long as the exact
+  invite-only sequence proof and source-row proof pass. If the raw output nests
   this in `finalCampaignRead` or `finalTableRead`, copy it to canonical
   `finalPausedSendProof.currentStep` and
   `finalPausedSendProof.campaignStatus`.
@@ -1088,9 +1121,14 @@ plain row generation. The lane worker must inline the same
    approvedGeneratedMessageCount exactly 1. Do not report completion with 2+
    approved rows.
    Approval shorthand: Do not report completion with 2+ approved rows.
-8. Continue to `attach_recommended_sequence({ campaignId, currentStep:"send" })`
-   and, if the campaign is still `DRAFT`, `pause_campaign({ campaignId })`.
-   Reread the campaign/table before claiming completion.
+8. Standard mode: continue to
+   `attach_recommended_sequence({ campaignId, currentStep:"send" })` and, if
+   the campaign is still `DRAFT`, `pause_campaign({ campaignId })`. Reread the
+   campaign/table before claiming completion.
+   Connection-only mode: skip Message Drafting and route-proof approval, call
+   `attach_sequence({ tableId, templateRef:"connection_only" })`, prove
+   `sequenceReceipt.actionTypes:["send_invite"]`, and pause/reread without
+   launching or sending.
 
 That packaged worker path must return `messageDraftingReceipt.statusSource:
 "packaged-generate-messages-worker"`. It is accepted only when the receipt
@@ -1515,11 +1553,14 @@ Message, and verify current-revision sample messages before final completion.
      - DM lanes: add a `Delivery format:` line — either `multiline (each paragraph sends as its own DM message)` or `single message`. When multiline, the template's blank-line paragraphs ARE the message boundaries — write each one as a standalone typed message.
      - **InMail lanes can never be multiline**: an InMail is one message and the recipient must reply before anything else can be sent. InMail-bound templates must read as one cohesive message — declare `Delivery format: single message (InMail — no follow-up until reply)` and never structure the copy to depend on multi-message pacing.
 
-   - The sequence is auto-selected by sender tier; do not hand-author sequence
+   - In standard mode, the sequence is auto-selected by sender tier; do not hand-author sequence
      templates here. Sales Nav/Recruiter senders may receive the unified Sales
      Nav cascade through `attach_recommended_sequence`; attaching it does not
      spend paid InMail credits by itself. Do not substitute the manual Paid
      InMail Campaign template.
+     For explicit connection-only evergreen lanes only, use the backend-owned
+     `attach_sequence({ tableId, templateRef:"connection_only" })` path and do
+     not call `attach_recommended_sequence`.
 3. **Customer-Visible Completion Contract**: a named evergreen lane that appears
    as a campaign card or campaign-backed table is not done when the shell exists.
    It is done only when the customer can open the campaign and land on final
@@ -1543,7 +1584,7 @@ Message, and verify current-revision sample messages before final completion.
       evergreen setup. Do not leave customer-visible campaigns at
       `filter-choice`, `filter-rules`, or `apply-icp-rubric` and report success.
       Do not proceed to Message Drafting until saved filters are applied.
-   - Message Drafting has run from the current campaign/table basis, using the
+   - In standard mode, Message Drafting has run from the current campaign/table basis, using the
      create-campaign message prompt/assets and validation gate. Updating
      `currentStep:"messages"` is not proof. Parent-thread handwritten copy is
      not a substitute. The proof receipt must show
@@ -1584,6 +1625,9 @@ Message, and verify current-revision sample messages before final completion.
       Fallback samples must still reject source/conversation hedges such as
       `"hope this is relevant"`, `"might be interested"`, or `"saw you in a few
       conversations"`.
+     For explicit connection-only lanes, this whole Message Drafting and sample
+     proof block is not required and must not be faked with parent-written
+     messages.
    - The first review batch exists and at least 3 review rows have generated
      messages from the approved brief. If fewer than 3 usable rows exist, report
      the actual count and why.
@@ -1596,7 +1640,7 @@ Message, and verify current-revision sample messages before final completion.
      completion, approve exactly one quality-valid generated row. If one or more
      rows are already approved, do not add more approvals during evergreen
      completion. Never broad approve all rows.
-    - The recommended tier-aware sequence is attached to the current campaign
+    - In standard mode, the recommended tier-aware sequence is attached to the current campaign
       table, and the watched campaign is on Send. Use
       `attach_recommended_sequence({ campaignId, currentStep:"send" })` when a
       safe attach is needed. After `confirm_lead_list` or any source-list copy,
@@ -1611,6 +1655,10 @@ Message, and verify current-revision sample messages before final completion.
       manual Paid InMail Campaign, and never attach/replace sequence outside the
       current table unless the current lane packet explicitly allowed sequence
       repair.
+      For explicit connection-only lanes, the current campaign table must have
+      exactly the canonical invite-only sequence:
+      `sequenceReceipt.actionTypes:["send_invite"]`. Any DM, InMail, or View
+      Profile action means the lane is not complete.
     - If the current campaign table is still `DRAFT` after sequence/readiness
       proof, call `pause_campaign({ campaignId })` and reread. `pause_campaign`
       is the product-native review-state transition; it is not a launch and does

package/skill-templates/refill-sends-v2.md

@@ -62,6 +62,11 @@ for lease expiry; never guess a fence.
 The default `intent:"auto"` inspects `managed_waterfall`,
 `dashboard_evergreen`, and `active_campaign` lane sources. Report the lane
 source and lane chain as proof for every selected sender.
+Connection-only evergreen lanes are invite-only refill targets. When the packet
+or campaign proof shows exactly `["send_invite"]`, report and execute only
+`selectedLane:"send_invite"` work; do not infer DM, InMail, Sales Nav cascade,
+paid-credit refresh, message generation, follow-up, sequence mutation,
+launch/start beyond packet authority, scheduler writes, or direct sends.
 
 If membership blocks a workspace read, report the structured
 `workspace_access` blocker instead of retrying auth or switching workspaces.

package/skill-templates/refill-sends.md

@@ -196,6 +196,11 @@ rather than asking which campaign class to fill. If a stale target plan selects
 planner before mutation.
 Short form: trust the target plan's inferred lane when it is a connection invite,
 paid-InMail refill lane, or unified Sales Nav cascade.
+Connection-only evergreen campaigns with exact `["send_invite"]` sequence proof
+are plain invite capacity: treat them as `selectedLane:"send_invite"` only. Do
+not infer DM, InMail, Sales Nav cascade, paid-credit refresh, message
+generation, follow-up, sequence mutation, launch/start, scheduling override, or
+direct-send work from a connection-only lane.
 
 Structured planner packet:
 

package/HERMES-SLACK-PROFILE-SCOPING.md

@@ -1,139 +0,0 @@
-# Hermes Slack Profile Scoping
-
-Use this when creating or updating customer Hermes profiles that need Slack
-access.
-
-## Default Rule
-
-Each Slack-enabled customer profile should have its own Slack app installation:
-
-- one profile-local `SLACK_BOT_TOKEN`
-- one profile-local `SLACK_APP_TOKEN`
-- one `SLACK_HOME_CHANNEL`
-- one fail-closed `SLACK_ALLOWED_CHANNELS` allowlist
-
-The bot should be invited only to the customer's managed channel, normally
-`sellable-{customerSlug}`.
-
-Shared Slack credentials can work for outbound-only smoke tests, but they are a
-weaker isolation model. Do not run multiple active Socket Mode listeners against
-the same Slack app token unless there is a separate dispatcher architecture that
-routes events to profiles.
-
-The 2026-07-06 Hostinger POC proved the native Hermes listener for the
-`sellable-admin` profile with the existing `Sellable Reply Bot` app in
-`#team-chat`: a human mention produced a new Hermes session and a threaded bot
-reply. Treat that as proof that the gateway/listener path works for one owning
-profile, not as approval for multiple active customer profiles sharing one app
-token.
-
-The same day, the `acme` profile reused the same redacted Slack token
-fingerprints for an outbound-only smoke to `#sellable-acme` via:
-
-```bash
-hermes --profile acme send --to slack:C0BFERDV3N0 --subject '[Hermes acme smoke]' ...
-```
-
-That succeeded and is useful as an internal smoke test. It does not change the
-inbound listener rule: only one profile should own an active Socket Mode
-connection for a given `SLACK_APP_TOKEN`.
-
-## Which Slack Values Are Enough
-
-For outbound sends and ordinary Slack Web API calls, the important value is the
-profile-local `SLACK_BOT_TOKEN`.
-
-For native Hermes live listening through Slack Socket Mode, the profile also
-needs `SLACK_APP_TOKEN`, an app-level `xapp-...` token with `connections:write`.
-`SLACK_APP_ID`, `SLACK_CLIENT_ID`, `SLACK_CLIENT_SECRET`,
-`SLACK_SIGNING_SECRET`, `SLACK_VERIFICATION_TOKEN`, `SLACK_TEAM_ID`, and
-`SLACK_OPERATOR_EMAIL` do not replace `SLACK_APP_TOKEN`.
-
-## Required Slack App Shape
-
-Outbound Slack sends can work with fewer permissions. Native Hermes inbound
-listening needs the Slack app itself to be configured for Socket Mode and event
-delivery:
-
-- Enable Socket Mode.
-- Create an app-level token with `connections:write`.
-- Install the bot with `app_mentions:read`, `channels:history`,
-  `channels:read`, `chat:write`, `groups:history`, `groups:read`,
-  `im:history`, `im:read`, `mpim:history`, `mpim:read`, and `users:read`.
-- Subscribe bot events for `app_mention`, `message.channels`,
-  `message.groups`, `message.im`, and `message.mpim`.
-- Reinstall the app after changing scopes or event subscriptions.
-
-If the Slack app has `incoming-webhook`, Slack will ask for a webhook channel
-during reinstall. Pick the profile home channel. That webhook selection does
-not replace `SLACK_ALLOWED_CHANNELS`; keep the profile-local allowlist explicit.
-
-## Bootstrap Command
-
-Use the Sellable installer profile bootstrap:
-
-```bash
-sellable hermes profile bootstrap \
-  --profile acme \
-  --profiles-root /srv/hermes/profiles \
-  --workspace-id ws_acme \
-  --workspace-name Acme \
-  --token-file /run/secrets/sellable-acme-token \
-  --slack-bot-token "$SLACK_BOT_TOKEN" \
-  --slack-app-token "$SLACK_APP_TOKEN" \
-  --slack-home-channel C0ACME12345 \
-  --slack-home-channel-name sellable-acme \
-  --slack-allowed-users U0OPERATOR1 \
-  --slack-require-mention true \
-  --json
-```
-
-If `--slack-home-channel` is supplied and `--slack-allowed-channels` is omitted,
-the installer writes `SLACK_ALLOWED_CHANNELS=<home-channel-id>` automatically.
-That makes the profile fail closed to the customer channel by default.
-
-Use `--slack-allowed-channels C...,G...` only when a profile is intentionally
-allowed to listen in more than one channel. Pass Slack IDs, not `#channel-name`
-strings or wildcards.
-
-## Resulting Profile Env
-
-The profile-local `.env` should contain only scoped Slack keys for that profile:
-
-```env
-SLACK_BOT_TOKEN=...
-SLACK_APP_TOKEN=...
-SLACK_HOME_CHANNEL=C0ACME12345
-SLACK_HOME_CHANNEL_NAME=sellable-acme
-SLACK_ALLOWED_CHANNELS=C0ACME12345
-SLACK_ALLOWED_USERS=U0OPERATOR1
-SLACK_REQUIRE_MENTION=true
-```
-
-Keep the file mode at `0600`. Do not copy raw tokens into planning docs, chat,
-or committed artifacts. Record token fingerprints only.
-
-## Verification
-
-Run the installer UAT before publishing installer changes:
-
-```bash
-npm run test:unit -- tests/install-package/agent-preferences.test.ts
-scripts/run-phase92-hermes-profile-bootstrap-uat.sh --mode local-temp
-scripts/run-phase92-hermes-profile-bootstrap-uat.sh --mode linux-shaped
-```
-
-Expected proof:
-
-- profile-local Sellable config paths remain authoritative
-- generated profile `.env` has `SLACK_HOME_CHANNEL`
-- generated profile `.env` has `SLACK_ALLOWED_CHANNELS`
-- `acme` allowlist points at the `sellable-acme` fixture channel id
-- redaction scan passes
-
-## Current Phase 03 Status
-
-Phase 03 has proved the profile-scoped installer path, outbound Hermes send
-path, and live Slack listener for the `sellable-admin` profile. The
-customer-specific app/token creation path remains the next hardening step before
-multiple active customer listeners are safe.