@sellable/install 0.1.315 → 0.1.317

package/HERMES-SLACK-PROFILE-SCOPING.md

@@ -0,0 +1,169 @@
+# Hermes Slack Profile Scoping
+
+Use this when creating or updating customer Hermes profiles that need Slack
+access.
+
+## Default Rule
+
+For Sellable-managed customer channels, use one dedicated Slack app/token pair
+per active Hermes customer profile. Run native `hermes -p <profile> gateway run`
+for that profile only. Do not run multiple active Hermes profile gateways
+against the same `SLACK_APP_TOKEN`.
+
+The customer's Slack app is bound to the exact Slack channel id and the
+customer's profile-local Sellable MCP config. Customer profiles must not store
+or read Sellable Admin MCP credentials, admin Slack app tokens, or sibling
+profile config.
+
+The shared dispatcher remains a fallback/research path only. Use it only when
+Sellable Admin explicitly owns one shared listener and route registry.
+
+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: each active customer profile needs its own native Slack
+app token pair unless Sellable Admin deliberately chooses the dispatcher
+fallback.
+
+## 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.
+
+## Profile 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
+
+For the dedicated customer Slack app model, 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.
+
+The profile's Hermes MCP env must also include the profile-local Sellable
+config, customer workspace lock, and fail-closed guard:
+
+```yaml
+SELLABLE_CONFIG_PATH: /srv/hermes/profiles/acme/sellable/config.json
+SELLABLE_CONFIGS_DIR: /srv/hermes/profiles/acme/sellable/configs
+SELLABLE_LOCK_WORKSPACE_ID: ws_acme
+SELLABLE_REQUIRE_WORKSPACE_LOCK: "1"
+```
+
+`SELLABLE_REQUIRE_WORKSPACE_LOCK=1` means an unbound customer profile fails
+closed before making Sellable API calls instead of falling back to shared or
+admin config state. Only the `sellable-admin` profile should provision,
+inspect, or repair other profiles.
+
+For the shared dispatcher model, do not copy the shared `SLACK_BOT_TOKEN` or
+`SLACK_APP_TOKEN` into customer profile `.env` files. The dispatcher owns those
+tokens and route metadata decides the customer profile.
+
+## Shared Dispatcher Ownership
+
+The shared Slack dispatcher and its route registry are fallback Sellable Admin
+surfaces. This customer-facing installer must not create shared route bundles or
+write shared listener tokens. Sellable Admin owns Slack app creation and profile
+provisioning, then calls this installer for profile-local Sellable runtime
+bootstrap inside the already-provisioned Hermes profile.
+
+## Verification
+
+Run the installer and dispatcher 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
+scripts/run-phase031-hermes-slack-dispatcher-uat.sh --mode local-fixture
+```
+
+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 proved the profile-scoped installer path, outbound Hermes send path,
+and live Slack listener for the `sellable-admin` profile. Phase 03.1 now targets
+dedicated native Slack apps per customer profile, profile-local Sellable MCP
+locks, and fail-closed customer profile behavior so managed customer channels
+can be onboarded through the VPS without local-only browser state, manual SSH
+edits, or untracked processes.

package/README.md

@@ -122,6 +122,17 @@ It creates:
 /srv/hermes/profiles/acme/.env        # only when Slack token inputs are supplied
 ```
 
+Bootstrap also writes `SELLABLE_LOCK_WORKSPACE_ID=<workspace-id>` and
+`SELLABLE_REQUIRE_WORKSPACE_LOCK=1` into the profile's Hermes MCP env.
+Customer profiles are therefore locked to their own Sellable workspace:
+Sellable MCP requests are forced to that workspace, workspace switching/creation
+is blocked, workspace listings are filtered, and a missing lock fails closed
+instead of falling back to shared/admin config. Use the `sellable-admin` profile
+for provisioning or cross-profile inspection.
+
+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:
@@ -142,6 +153,36 @@ 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

@@ -179,6 +179,8 @@ Options:
   --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.
+  --require-workspace-lock  For Hermes customer profiles, fail closed unless
+                            SELLABLE_LOCK_WORKSPACE_ID is present in MCP env.
   --api-url <url>           Sellable API URL. Default: ${DEFAULT_API_URL}
   --sellable-config-path <path>
                             Profile-scoped Sellable config path. Also reads SELLABLE_CONFIG_PATH.
@@ -217,9 +219,20 @@ Hermes profile bootstrap:
 
   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.
+  <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 credentials and customer-scoped Slack credentials for
+  customer profiles; shared admin tokens are weaker isolation and should remain
+  internal-only. Bootstrap writes SELLABLE_REQUIRE_WORKSPACE_LOCK=1 whenever a
+  workspace id is supplied, so a customer profile fails closed if the workspace
+  lock is later removed or not yet provisioned.
+
+Hermes shared Slack dispatcher:
+  Shared listener setup and route-registry validation are internal Sellable
+  Admin responsibilities. This customer-facing installer only bootstraps a
+  profile-local Sellable runtime after Sellable Admin provisions the profile
+  and dispatcher route.
 `;
 }
 
@@ -3505,6 +3518,12 @@ function mcpEnvForHost(host, opts) {
   if (opts.sellableConfigsDir) {
     env.SELLABLE_CONFIGS_DIR = opts.sellableConfigsDir;
   }
+  if (opts.lockWorkspaceId) {
+    env.SELLABLE_LOCK_WORKSPACE_ID = opts.lockWorkspaceId;
+  }
+  if (opts.requireWorkspaceLock) {
+    env.SELLABLE_REQUIRE_WORKSPACE_LOCK = "1";
+  }
   return env;
 }
 
@@ -3789,6 +3808,12 @@ 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 || "",
@@ -3797,6 +3822,7 @@ function parseHermesProfileBootstrapArgs(argv) {
     force: false,
     overwriteEnv: false,
     allowDuplicateSlackTokens: false,
+    requireWorkspaceLock: false,
     verbose: false,
   };
 
@@ -3821,6 +3847,12 @@ 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());
@@ -3829,7 +3861,9 @@ function parseHermesProfileBootstrapArgs(argv) {
     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") {
+    else if (arg === "--require-workspace-lock") {
+      opts.requireWorkspaceLock = true;
+    } else if (arg === "--allow-duplicate-slack-tokens") {
       opts.allowDuplicateSlackTokens = true;
     } else if (arg === "--verbose") opts.verbose = true;
     else {
@@ -3922,6 +3956,111 @@ 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);
@@ -3974,10 +4113,16 @@ 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: parsed.slackBotToken.trim(),
-      SLACK_APP_TOKEN: parsed.slackAppToken.trim(),
+      SLACK_BOT_TOKEN: slackEnv.SLACK_BOT_TOKEN,
+      SLACK_APP_TOKEN: slackEnv.SLACK_APP_TOKEN,
     };
+    const slackEnvKeys = Object.entries(slackEnv)
+      .filter(([, value]) => value)
+      .map(([key]) => key);
+    const requireWorkspaceLock =
+      parsed.requireWorkspaceLock || Boolean(parsed.workspaceId);
     const opts = {
       ...parsed,
       host: "hermes",
@@ -3987,6 +4132,8 @@ function runHermesProfileBootstrap(argv) {
       token,
       tokenSource,
       workspaceId: parsed.workspaceId,
+      lockWorkspaceId: parsed.workspaceId,
+      requireWorkspaceLock,
       apiUrl: parsed.apiUrl,
     };
 
@@ -4011,6 +4158,17 @@ function runHermesProfileBootstrap(argv) {
         apiUrl: opts.apiUrl,
         activeWorkspaceId: parsed.workspaceId || null,
         activeWorkspaceName: parsed.workspaceName || null,
+        workspaceLock: parsed.workspaceId
+          ? {
+              enabled: true,
+              workspaceId: parsed.workspaceId,
+              required: requireWorkspaceLock,
+            }
+          : {
+              enabled: false,
+              workspaceId: null,
+              required: requireWorkspaceLock,
+            },
         tokenPresent: Boolean(token),
         tokenSource,
         tokenFingerprint: tokenFingerprint(token),
@@ -4019,11 +4177,29 @@ 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: [],
@@ -4068,7 +4244,7 @@ function runHermesProfileBootstrap(argv) {
     if (existsSync(envPath)) {
       envState = parseEnvLines(readFileSync(envPath, "utf8"));
     }
-    for (const [key, value] of Object.entries(slackTokens)) {
+    for (const [key, value] of Object.entries(slackEnv)) {
       if (!value) continue;
       const existing = envState.entries.get(key);
       if (existing && existing !== value && !opts.overwriteEnv) {
@@ -4128,8 +4304,8 @@ function runHermesProfileBootstrap(argv) {
       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 (Object.values(slackEnv).some(Boolean)) {
+        for (const [key, value] of Object.entries(slackEnv)) {
           if (value) envState.entries.set(key, value);
         }
         writeFile(envPath, renderEnvFile(envState), opts, 0o600);
@@ -4144,16 +4320,31 @@ function runHermesProfileBootstrap(argv) {
       hermesConfigPath(opts)
     );
     (skillsExisted ? summary.updated : summary.created).push(hermesSkillsRoot(opts));
-    if (Object.values(slackTokens).some(Boolean)) {
+    if (Object.values(slackEnv).some(Boolean)) {
       (envExisted ? summary.updated : summary.created).push(envPath);
     } else {
-      summary.skipped.push("Slack env: no Slack tokens supplied");
+      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."
+      );
     }
     if (!token) {
       summary.warnings.push(
         `Manual auth pending. Run: sellable auth set <token> --workspace-id <workspace_id> --sellable-config-path ${sellableConfigPath}`
       );
     }
+    if (requireWorkspaceLock && !parsed.workspaceId) {
+      summary.warnings.push(
+        "Sellable MCP will fail closed until sellable-admin provisions SELLABLE_LOCK_WORKSPACE_ID for this customer profile."
+      );
+    }
 
     if (opts.json) {
       console.log(JSON.stringify(summary, null, 2));

package/lib/runtime-verify.mjs

@@ -45,14 +45,6 @@ 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",
@@ -92,14 +84,6 @@ 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: {
@@ -203,43 +187,6 @@ 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);
@@ -283,26 +230,10 @@ 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: 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,
+      promptChars: typeof parsed.prompt === "string" ? parsed.prompt.length : 0,
       hasMore: parsed.hasMore === true,
       nextOffset:
         typeof parsed.nextOffset === "number" ? parsed.nextOffset : null,
@@ -336,7 +267,6 @@ async function verifyCreateCampaignSmoke({
     .map((call) => call.name)
     .filter((name) => !available.has(name));
   const calls = [];
-  const connectionOnlyEvergreenProofs = emptyConnectionOnlyEvergreenProofs();
 
   if (missingTools.length > 0) {
     return {
@@ -350,195 +280,67 @@ async function verifyCreateCampaignSmoke({
   }
 
   for (const call of smokeCalls) {
-    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 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(),
-          };
+    const callStartedAt = new Date().toISOString();
+    try {
+      const result = await client.callTool(
+        { name: call.name, arguments: call.arguments },
+        undefined,
+        {
+          timeout: timeoutMs,
+          maxTotalTimeout: timeoutMs,
         }
-
-        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(),
-        });
+      );
+      const summary = summarizeToolResult(call.name, result);
+      calls.push({
+        name: call.name,
+        arguments: call.arguments,
+        ok: summary.isError !== true,
+        summary,
+        startedAt: callStartedAt,
+        completedAt: new Date().toISOString(),
+      });
+      if (summary.isError === true) {
         return {
           ok: false,
           missingTools: [],
           calls,
-          error: redact(error),
+          error: `${call.name} returned an MCP tool error`,
           startedAt,
           completedAt: new Date().toISOString(),
         };
       }
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      calls.push({
+        name: call.name,
+        arguments: call.arguments,
+        ok: false,
+        summary: null,
+        error: redact(error),
+        startedAt: callStartedAt,
+        completedAt: new Date().toISOString(),
+      });
+      return {
+        ok: false,
+        missingTools: [],
+        calls,
+        error: redact(error),
+        startedAt,
+        completedAt: new Date().toISOString(),
+      };
     }
   }
 
-  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,
@@ -546,12 +348,6 @@ 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
       ? {
@@ -623,7 +419,6 @@ async function verifySellableMcpRuntimeOnce({
   let missingTools = [...requiredTools];
   let forbiddenTools = [];
   let createCampaignSmoke = null;
-  let connectionOnlyEvergreenContract = { ok: false, issues: [] };
   let error = null;
 
   try {
@@ -637,8 +432,6 @@ async function verifySellableMcpRuntimeOnce({
     forbiddenTools = availableTools.filter((tool) =>
       FORBIDDEN_SELLABLE_MCP_TOOLS.includes(tool)
     );
-    connectionOnlyEvergreenContract =
-      verifyConnectionOnlyEvergreenContract(toolList.tools);
     if (forbiddenTools.length > 0) {
       createCampaignSmoke = {
         ok: false,
@@ -682,7 +475,6 @@ async function verifySellableMcpRuntimeOnce({
       !error &&
       missingTools.length === 0 &&
       forbiddenTools.length === 0 &&
-      connectionOnlyEvergreenContract.ok === true &&
       createCampaignSmoke?.ok === true,
     skipped: false,
     command,
@@ -691,7 +483,6 @@ 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.315",
+  "version": "0.1.317",
   "type": "module",
   "description": "One-command installer for Sellable MCP in Claude Code, Codex, and Hermes",
   "bin": {
@@ -15,7 +15,8 @@
     "lib",
     "agents",
     "skill-templates",
-    "README.md"
+    "README.md",
+    "HERMES-SLACK-PROFILE-SCOPING.md"
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.2",

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

@@ -134,19 +134,6 @@ 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 and persists `currentStep:"send"` as the paused
-    review step. It does not require Message Drafting, generated messages,
-    route-proof approval, first DM, InMail, View Profile fallback, follow-up
-    branch, 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
@@ -733,9 +720,6 @@ 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
@@ -826,40 +810,22 @@ 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", currentStep:"send" })`, 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"` for standard and
-  connection-only customer-visible lanes. `send` is the product's paused
-  review step; do not use unsupported aliases such as `review` as final proof.
-  If the raw output nests this in `finalCampaignRead` or `finalTableRead`, copy
-  it to canonical
+  `currentStep:"send"` and `campaignStatus:"PAUSED"`. If the raw output nests
+  this in `finalCampaignRead` or `finalTableRead`, copy it to canonical
   `finalPausedSendProof.currentStep` and
   `finalPausedSendProof.campaignStatus`.
 - `verifyCall`: the exact `setup_evergreen_campaigns({ mode:"verify",
@@ -1122,14 +1088,9 @@ 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. 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", currentStep:"send" })`, prove
-   `sequenceReceipt.actionTypes:["send_invite"]`, and pause/reread without
-   launching or sending.
+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.
 
 That packaged worker path must return `messageDraftingReceipt.statusSource:
 "packaged-generate-messages-worker"`. It is accepted only when the receipt
@@ -1554,14 +1515,11 @@ 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.
 
-   - In standard mode, the sequence is auto-selected by sender tier; do not hand-author sequence
+   - 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", currentStep:"send" })` 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
@@ -1585,7 +1543,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.
-   - In standard mode, Message Drafting has run from the current campaign/table basis, using the
+   - 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
@@ -1626,9 +1584,6 @@ 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.
@@ -1641,7 +1596,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.
-    - In standard mode, the recommended tier-aware sequence is attached to the current campaign
+    - 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,
@@ -1656,10 +1611,6 @@ 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,11 +62,6 @@ 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,11 +196,6 @@ 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: