@sellable/install 0.1.310 → 0.1.312

package/README.md

@@ -119,30 +119,9 @@ It creates:
 /srv/hermes/profiles/acme/sellable/config.json
 /srv/hermes/profiles/acme/sellable/configs/
 /srv/hermes/profiles/acme/skills/sellable/
-/srv/hermes/bin/entrypoint-acme.sh
 /srv/hermes/profiles/acme/.env        # only when Slack token inputs are supplied
 ```
 
-For profile paths under a gateway root such as
-`/srv/hermes/profiles/acme`, bootstrap also registers
-`/srv/hermes/profiles/acme/skills/sellable` in the gateway root
-`/srv/hermes/config.yaml` as `skills.external_dirs`. Keep this behavior:
-Hermes Desktop command autocomplete scans the gateway/root skill config, not
-only the selected profile's local skill tree.
-
-Bootstrap also writes `/srv/hermes/bin/entrypoint-acme.sh`. Point the Hermes
-Docker service at that script when this profile should be the Desktop/dashboard
-default:
-
-```yaml
-entrypoint: ["/opt/data/bin/entrypoint-acme.sh"]
-```
-
-The wrapper starts `hermes gateway run` when needed, then intentionally runs
-`hermes -p acme dashboard --isolated`. Without `--isolated`, Hermes OS chat can
-see `/sellable-*` commands while Hermes Desktop autocomplete misses them because
-the dashboard backend is not scoped to the selected profile.
-
 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:

package/bin/sellable-install.mjs

@@ -13,7 +13,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { homedir } from "node:os";
-import { basename, dirname, join, relative, resolve } 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";
@@ -1180,10 +1180,9 @@ const REFRESH_SENDER_ENGAGEMENT_ALLOWED_TOOLS = [
   "mcp__sellable__get_campaign_table_schema",
   "mcp__sellable__list_tables",
   "mcp__sellable__get_rows_minimal",
+  "mcp__sellable__refresh_sender_engagement",
   "mcp__sellable__fetch_linkedin_posts",
-  "mcp__sellable__select_promising_posts",
   "mcp__sellable__fetch_post_engagers",
-  "mcp__sellable__add_on_demand_leads",
 ];
 
 function allowedToolsYaml(tools) {
@@ -2145,10 +2144,10 @@ ${allowedToolsYaml(REFRESH_SENDER_ENGAGEMENT_ALLOWED_TOOLS)}
 
 Use this as the customer-facing entrypoint for the Sellable
 \`refresh-sender-engagement\` workflow. It finds active sender-owned Post
-Engagers / Signal Discovery campaigns, fetches recent sender-authored LinkedIn
-posts, pulls latest engagers, filters to ICP, and adds net-new leads with
-dedupe. It never creates messages, approves rows, schedules sends, or launches
-campaigns.
+Engagers campaigns, runs the typed \`refresh_sender_engagement\` command in
+\`mode:"dry_run"\`, and gates any \`mode:"apply"\` call with the returned
+\`dryRunFingerprint\`. It never creates messages, approves rows, schedules
+sends, or launches campaigns.
 
 ## Bootstrap
 
@@ -2168,9 +2167,15 @@ Desktop, then start a new thread.
    \`mcp__sellable__get_subskill_prompt({ subskillName: "refresh-sender-engagement" })\`.
    If the response has \`hasMore=true\`, continue with \`nextOffset\` until
    \`hasMore=false\`.
-3. Follow the canonical prompt exactly. Target active/paused sender-owned Post
-   Engagers campaigns backed by Signal Discovery, and do not touch shared lanes
-   or send-state tools.
+3. Follow the canonical prompt exactly. Prefer
+   \`mcp__sellable__refresh_sender_engagement\` for dry-run and apply. Do not use
+   primitive lead import tools as an alternate write path.
+4. For manual runs, show the dry-run target workspace, sender, campaign/table,
+   expected impact, and \`dryRunFingerprint\`; wait for explicit approval before
+   apply. For scheduled automations, apply only with the fingerprint from the
+   immediately preceding dry run.
+5. Do not touch shared lanes, campaign status, approval, message preparation, or
+   send-state tools.
 
 ## MCP Prompt Fallback
 
@@ -3663,87 +3668,6 @@ function hermesSkillsRoot(opts = {}) {
   return join(hermesHome(opts), "skills", "sellable");
 }
 
-function hermesGatewayRoot(opts = {}) {
-  const profileRoot = hermesHome(opts);
-  const profilesRoot = dirname(profileRoot);
-  if (basename(profilesRoot) !== "profiles") return null;
-  return dirname(profilesRoot);
-}
-
-function hermesGatewayConfigPath(opts = {}) {
-  const root = hermesGatewayRoot(opts);
-  if (!root) return null;
-  return join(root, "config.yaml");
-}
-
-function hermesDashboardEntrypointPath(opts = {}, profile = "") {
-  const root = hermesGatewayRoot(opts);
-  if (!root) return null;
-  const safeProfile = String(profile || basenameSafe(hermesHome(opts))).replace(
-    /[^A-Za-z0-9_.-]/g,
-    "_"
-  );
-  return join(root, "bin", `entrypoint-${safeProfile}.sh`);
-}
-
-function hermesDashboardCommand(profile) {
-  return `hermes -p ${profile} dashboard --isolated --host 0.0.0.0 --port 4860 --no-open --skip-build`;
-}
-
-function hermesDashboardEntrypointContent(opts, profile) {
-  const quotedProfile = shellQuote(profile);
-  const quotedProfileRoot = shellQuote(hermesHome(opts));
-  const gatewayRoot = hermesGatewayRoot(opts);
-  const quotedGatewayRoot = shellQuote(gatewayRoot || dirname(hermesHome(opts)));
-  const quotedDashboardLog = shellQuote(join(hermesHome(opts), "logs", "dashboard.log"));
-  return `#!/usr/bin/env bash
-set -euo pipefail
-
-# This file is generated by sellable hermes profile bootstrap.
-# It preserves the Hostinger image startup shape, but launches the dashboard in
-# an isolated Sellable profile. Without --isolated, Hermes OS chat can see
-# profile skills while Desktop slash autocomplete stays on the default profile.
-profile=${quotedProfile}
-profile_root=${quotedProfileRoot}
-gateway_root=${quotedGatewayRoot}
-dashboard_log=${quotedDashboardLog}
-dashboard_port="\${HERMES_DASHBOARD_PORT:-4860}"
-run_as=()
-if command -v gosu >/dev/null 2>&1; then
-  run_as=(gosu hermes)
-fi
-
-chown -R hermes:hermes "$gateway_root" 2>/dev/null || true
-mkdir -p "$gateway_root/logs" "$profile_root/logs"
-chown -R hermes:hermes "$gateway_root/logs" "$profile_root/logs" 2>/dev/null || true
-
-if [[ -f "$gateway_root/config.yaml" ]]; then
-  if ! pgrep -f "hermes gateway run" >/dev/null 2>&1; then
-    "\${run_as[@]}" nohup hermes gateway run >>"$gateway_root/logs/gateway.log" 2>&1 </dev/null &
-  fi
-fi
-
-for v in ADMIN_USERNAME ADMIN_PASSWORD; do
-  if [[ -z "\${!v:-}" ]]; then
-    echo "missing required environment variable $v" >&2
-    exit 1
-  fi
-done
-
-export HERMES_DASHBOARD_BASIC_AUTH_USERNAME="$ADMIN_USERNAME"
-export HERMES_DASHBOARD_BASIC_AUTH_PASSWORD="$ADMIN_PASSWORD"
-
-exec "\${run_as[@]}" hermes -p "$profile" dashboard --isolated --host 0.0.0.0 --port "$dashboard_port" --no-open --skip-build >>"$dashboard_log" 2>&1
-`;
-}
-
-function writeHermesDashboardEntrypoint(opts, profile) {
-  const path = hermesDashboardEntrypointPath(opts, profile);
-  if (!path) return null;
-  writeFile(path, hermesDashboardEntrypointContent(opts, profile), opts, 0o755);
-  return path;
-}
-
 function hermesLikelyInstalled() {
   return (
     Boolean(process.env.HERMES_HOME?.trim()) ||
@@ -3823,38 +3747,6 @@ function writeHermesMcpServer(opts) {
   return configPath;
 }
 
-function writeHermesGatewaySkillDirectory(opts) {
-  const configPath = hermesGatewayConfigPath(opts);
-  if (!configPath || configPath === hermesConfigPath(opts)) return null;
-
-  const skillDir = hermesSkillsRoot(opts);
-  const raw = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
-  const config = parseHermesConfig(raw, configPath);
-  // Hermes Desktop slash autocomplete scans the gateway/root HERMES_HOME. A
-  // profile can execute its own skills without this, but Desktop will not show
-  // /sellable-* commands until the root scanner sees the profile skill dir.
-  const skills =
-    config.skills && typeof config.skills === "object" && !Array.isArray(config.skills)
-      ? config.skills
-      : {};
-  const current = Array.isArray(skills.external_dirs)
-    ? skills.external_dirs
-    : skills.external_dirs
-      ? [skills.external_dirs]
-      : [];
-  const externalDirs = current.includes(skillDir) ? current : [...current, skillDir];
-  const nextConfig = {
-    ...config,
-    skills: {
-      ...skills,
-      external_dirs: externalDirs,
-    },
-  };
-
-  writeHermesConfig(configPath, nextConfig, opts);
-  return { configPath, skillDir };
-}
-
 function installHermesSkills(opts) {
   const root = hermesSkillsRoot(opts);
   for (const skill of hermesSkillDefinitions()) {
@@ -3875,15 +3767,8 @@ function installHermes(opts) {
   try {
     skillsRoot = installHermesSkills(opts);
     const configPath = writeHermesMcpServer(opts);
-    const gateway = writeHermesGatewaySkillDirectory(opts);
     logVerbose(`${C.grey}+ Hermes config updated: ${configPath}${C.reset}`);
-    return {
-      installed: true,
-      configPath,
-      skillsRoot,
-      gatewayConfigPath: gateway?.configPath || null,
-      gatewayExternalSkillsDir: gateway?.skillDir || null,
-    };
+    return { installed: true, configPath, skillsRoot };
   } catch (err) {
     if (skillsRoot && !opts.dryRun) {
       rmSync(skillsRoot, { recursive: true, force: true });
@@ -4121,8 +4006,6 @@ function runHermesProfileBootstrap(argv) {
         sellableConfigPath,
         sellableConfigsDir,
         skillsRoot: hermesSkillsRoot(opts),
-        gatewayConfigPath: hermesGatewayConfigPath(opts),
-        hermesDashboardEntrypointPath: hermesDashboardEntrypointPath(opts, profile),
       },
       auth: {
         apiUrl: opts.apiUrl,
@@ -4142,12 +4025,6 @@ function runHermesProfileBootstrap(argv) {
             .map(([key, value]) => [key, tokenFingerprint(value)])
         ),
       },
-      dashboard: {
-        command: hermesDashboardCommand(profile),
-        composeEntrypoint: hermesDashboardEntrypointPath(opts, profile)
-          ? `entrypoint: ["${hermesDashboardEntrypointPath(opts, profile)}"]`
-          : null,
-      },
       created: [],
       updated: [],
       preserved: [],
@@ -4213,12 +4090,6 @@ function runHermesProfileBootstrap(argv) {
     }
 
     const hermesConfigExisted = existsSync(hermesConfigPath(opts));
-    const gatewayConfigPath = hermesGatewayConfigPath(opts);
-    const gatewayConfigExisted = gatewayConfigPath ? existsSync(gatewayConfigPath) : false;
-    const dashboardEntrypointPath = hermesDashboardEntrypointPath(opts, profile);
-    const dashboardEntrypointExisted = dashboardEntrypointPath
-      ? existsSync(dashboardEntrypointPath)
-      : false;
     const skillsExisted = existsSync(hermesSkillsRoot(opts));
     const authExisted = existsSync(sellableConfigPath);
     const configsDirExisted = existsSync(sellableConfigsDir);
@@ -4257,7 +4128,6 @@ function runHermesProfileBootstrap(argv) {
       mkdirSync(sellableConfigsDir, { recursive: true, mode: 0o700 });
       writeHermesProfileSellableConfig(sellableConfigPath, nextAuth, opts);
       installHermes(opts);
-      writeHermesDashboardEntrypoint(opts, profile);
       if (Object.values(slackTokens).some(Boolean)) {
         for (const [key, value] of Object.entries(slackTokens)) {
           if (value) envState.entries.set(key, value);
@@ -4273,20 +4143,6 @@ function runHermesProfileBootstrap(argv) {
     (hermesConfigExisted ? summary.updated : summary.created).push(
       hermesConfigPath(opts)
     );
-    if (gatewayConfigPath) {
-      (gatewayConfigExisted ? summary.updated : summary.created).push(
-        gatewayConfigPath
-      );
-    }
-    if (dashboardEntrypointPath) {
-      (dashboardEntrypointExisted ? summary.updated : summary.created).push(
-        dashboardEntrypointPath
-      );
-    } else {
-      summary.skipped.push(
-        "Hermes dashboard entrypoint: profile root is not under a gateway profiles directory"
-      );
-    }
     (skillsExisted ? summary.updated : summary.created).push(hermesSkillsRoot(opts));
     if (Object.values(slackTokens).some(Boolean)) {
       (envExisted ? summary.updated : summary.created).push(envPath);

package/lib/runtime-verify.mjs

@@ -35,6 +35,7 @@ export const REQUIRED_SELLABLE_MCP_TOOLS = [
   "refresh_paid_inmail_credits",
   "run_scheduler_sweep",
   "refill_sends",
+  "refresh_sender_engagement",
   "setup_evergreen_campaigns",
   "start_campaign_message_preparation",
   "get_campaign_message_preparation_status",
@@ -75,6 +76,22 @@ export const CREATE_CAMPAIGN_SMOKE_CALLS = [
       limit: 1200,
     },
   },
+  {
+    name: "get_subskill_prompt",
+    arguments: {
+      subskillName: "refresh-sender-engagement",
+      offset: 0,
+      limit: 1200,
+    },
+  },
+  {
+    name: "get_subskill_prompt",
+    arguments: {
+      subskillName: "create-evergreen-campaigns",
+      offset: 0,
+      limit: 4000,
+    },
+  },
   {
     name: "refill_sends",
     arguments: {
@@ -221,10 +238,17 @@ function summarizeToolResult(name, result) {
   }
 
   if (name === "get_subskill_prompt" && parsed) {
+    const prompt = typeof parsed.prompt === "string" ? parsed.prompt : "";
     return {
       ...summary,
       subskillName: parsed.name || null,
-      promptChars: typeof parsed.prompt === "string" ? parsed.prompt.length : 0,
+      promptChars: prompt.length,
+      connectionOnlyEvergreenGuidance:
+        parsed.name === "create-evergreen-campaigns"
+          ? prompt.includes('campaignSequenceOptions:{ mode:"connection_only" }') &&
+            prompt.includes('templateRef:"connection_only"') &&
+            prompt.includes('sequenceReceipt.actionTypes:["send_invite"]')
+          : null,
       hasMore: parsed.hasMore === true,
       nextOffset:
         typeof parsed.nextOffset === "number" ? parsed.nextOffset : null,
@@ -300,6 +324,21 @@ async function verifyCreateCampaignSmoke({
           completedAt: new Date().toISOString(),
         };
       }
+      if (
+        call.name === "get_subskill_prompt" &&
+        call.arguments?.subskillName === "create-evergreen-campaigns" &&
+        summary.connectionOnlyEvergreenGuidance !== true
+      ) {
+        return {
+          ok: false,
+          missingTools: [],
+          calls,
+          error:
+            "create-evergreen-campaigns prompt is missing connection-only guidance",
+          startedAt,
+          completedAt: new Date().toISOString(),
+        };
+      }
     } catch (err) {
       const error = err instanceof Error ? err.message : String(err);
       calls.push({
@@ -332,6 +371,37 @@ async function verifyCreateCampaignSmoke({
   };
 }
 
+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,
@@ -339,6 +409,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
       ? {
@@ -410,6 +486,7 @@ async function verifySellableMcpRuntimeOnce({
   let missingTools = [...requiredTools];
   let forbiddenTools = [];
   let createCampaignSmoke = null;
+  let connectionOnlyEvergreenContract = { ok: false, issues: [] };
   let error = null;
 
   try {
@@ -423,6 +500,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,
@@ -466,6 +545,7 @@ async function verifySellableMcpRuntimeOnce({
       !error &&
       missingTools.length === 0 &&
       forbiddenTools.length === 0 &&
+      connectionOnlyEvergreenContract.ok === true &&
       createCampaignSmoke?.ok === true,
     skipped: false,
     command,
@@ -474,6 +554,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.310",
+  "version": "0.1.312",
   "type": "module",
   "description": "One-command installer for Sellable MCP in Claude Code, Codex, and Hermes",
   "bin": {

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/skill-templates/refresh-sender-engagement.md

@@ -19,10 +19,9 @@ allowed-tools:
   - mcp__sellable__get_campaign_table_schema
   - mcp__sellable__list_tables
   - mcp__sellable__get_rows_minimal
+  - mcp__sellable__refresh_sender_engagement
   - mcp__sellable__fetch_linkedin_posts
-  - mcp__sellable__select_promising_posts
   - mcp__sellable__fetch_post_engagers
-  - mcp__sellable__add_on_demand_leads
 ---
 
 # Refresh Sender Engagement
@@ -34,7 +33,7 @@ You are a pipeline supply agent. People who engage with a sender's LinkedIn post
 <inputs>
 The invoking prompt names the senders ("refresh sender engagement for csreyes92 and thomas"). Resolve each via `list_senders` (match name/handle/LinkedIn URL). With no names given, inspect the active workspace and refresh every connected sender that has an active/paused sender-owned Post Engagers campaign backed by Signal Discovery.
 
-Optional: lookback window (default: posts from the last 30 days), engagement sources (default `both` reactions+comments), target sender names/ids, maximum posts per sender (default 5, hard cap 5 unless the user explicitly asks for more), and target campaign ids/names when the user wants to force a specific campaign.
+Optional: target sender names/ids, `tableId` when the user wants to force a specific campaign table, maximum posts per sender (default 5, hard cap 5 unless the user explicitly asks for more), and maximum engager pages per tracked post.
 </inputs>
 
 <entrypoint>
@@ -53,39 +52,36 @@ suggest `refill-sends`.
 <objective>
 For each target sender/campaign:
 
-1. **Find active Signal Discovery/Post Engagers campaigns first**:
+1. **Authenticate and resolve workspace**:
    - Call `get_auth_status` and confirm the active workspace.
-   - Call `get_campaigns` and, when needed, `list_tables`/`get_campaign` to find candidate campaigns.
-   - Keep only active or paused campaign-backed sender-owned Post Engagers campaigns. Strong signals include campaign/table names like `<Sender> - Post Engagers`, `sourceProvider:"signal-discovery"`, sender attachment to exactly one sender, and source/list/table readback indicating post engagers.
-   - Exclude shared Signal Discovery lanes, Shared Cold Fallback lanes, archived/completed campaigns, non-campaign tables, direct/on-demand-only campaigns, and any campaign attached to multiple senders unless the user explicitly selected it and the readback proves it is sender-owned.
-   - If no matching campaign exists for a sender, report "no active Post Engagers Signal Discovery campaign — create one first" and skip; do not silently create campaigns.
-2. **Resolve the sender and source boundary**:
-   - Match each candidate campaign to its sender from `list_senders`/`get_sender`.
-   - Use the sender's own LinkedIn profile URL/handle as the only source author boundary.
-   - Never scrape third-party authors into a sender-owned Post Engagers campaign.
-3. **Find relevant sender-authored posts to refresh**:
-   - Call `fetch_linkedin_posts({ linkedinUrl: sender profile, limit: 25 })`.
-   - Keep original posts authored by that exact sender, not reposts, from the lookback window.
-   - Rank posts by recency, engagement count, and fit to the campaign's buyer/problem/topic. Prefer posts likely to attract the target buyer over generic company updates.
-   - If the campaign has an existing Signal Discovery/source state that names tracked/selected posts, prefer refreshing those posts when they are still inside the lookback window and relevant; otherwise choose the strongest recent sender-authored posts.
-   - When the product flow expects selected posts to be visible, call `select_promising_posts` before scraping.
-4. **Pull latest engagers**:
-   - For the top posts (up to 5 per sender per run), call `fetch_post_engagers({ postUrl, sources })`.
-   - Default `sources` to `"both"` unless the user requested reactions-only or comments-only.
-5. **Filter to ICP** using the campaign's existing headline ICP criteria (from `get_campaign` brief/rubrics/table schema). Judge each engager's headline against those criteria; exclude obvious non-fits, the sender's own colleagues, existing employees, students/job-seekers, competitors, and anyone with no usable headline. When the campaign has no criteria, keep likely decision-makers/operators and exclude weak-fit profiles.
-6. **Add net-new leads only**:
-   - Use `add_on_demand_leads({ tableId, leads, skipDuplicates: true })` with name, headline-derived title, profile URL, and source/post context where the tool accepts it.
-   - Dedupe is mandatory. Never disable dedupe on a scheduled run.
-   - Do not generate, approve, schedule, or send messages.
-7. **Report**: campaigns inspected, target campaigns selected, posts scanned, engagers found, ICP-passing, net-new added per sender/campaign. If a sender posted nothing in the window, say "no recent posts — nothing to refresh" (that is a truthful no-op, not a failure).
+   - If there is no active workspace or auth is missing, stop with the MCP guidance. Do not use local env files or repo scripts as a substitute for MCP auth.
+   - Resolve each target sender with `list_senders`/`get_sender`. Use the sender id returned by the product, not a guessed handle.
+2. **Use the typed product command first**:
+   - Call `refresh_sender_engagement` in `mode:"dry_run"` for each sender.
+   - Always pass `workspaceId`, `senderId`, and any user-specified `tableId`, `maxPosts`, or `maxEngagerPages`.
+   - Treat the dry-run response as the campaign/source boundary authority. It should identify the sender-owned Post Engagers slot, campaign, workflow table, source provider `campaign-tracked-post`, source table type `tracked_post_engager_source_list`, expected tracked posts, expected engager refresh/import work, and a `dryRunFingerprint`.
+   - If the typed command reports no eligible sender-owned Post Engagers campaign, no tracked posts, no recent posts, or a workspace/sender mismatch, report that exact blocker and stop for that sender. Do not silently create campaigns or fall back to shared lanes.
+3. **Gate writes with dry-run proof**:
+   - Never call `refresh_sender_engagement` in `mode:"apply"` before a successful dry run from this same run.
+   - For manual runs, show the target workspace, sender, campaign/table, source lead list, expected tracked posts, expected row/import impact, and `dryRunFingerprint`, then wait for explicit user approval before apply.
+   - For scheduled automations where the user has already authorized refreshes, apply is allowed only with the exact `dryRunFingerprint` from the immediately preceding dry run.
+   - If apply rejects the fingerprint as stale or mismatched, rerun dry-run and ask for approval again for manual runs.
+4. **Apply through the typed command only**:
+   - Call `refresh_sender_engagement({ mode:"apply", workspaceId, senderId, tableId?, maxPosts?, maxEngagerPages?, dryRunFingerprint })`.
+   - The apply path must materialize/refresh tracked posts, import deduped tracked-post engagers into the campaign table, and preserve product idempotency. Do not use `add_on_demand_leads` or raw table row writes for the same operation.
+5. **Read-only fallback is diagnostic only**:
+   - If the typed command is unavailable, use `get_subskill_prompt`/`search_subskill_prompts` and stop with `blocked: missing_refresh_sender_engagement_tool`.
+   - `fetch_linkedin_posts` and `fetch_post_engagers` may be used only to explain source availability or diagnose provider issues. They are not an alternate write path.
+6. **Report**: campaigns inspected, target campaign/table, tracked posts materialized/refreshed, engagers scanned, ICP-passing/importable, net-new rows imported, duplicates skipped, and any no-op reason per sender/campaign. If a sender posted nothing in the window, say "no recent posts — nothing to refresh" (that is a truthful no-op, not a failure).
 </objective>
 
 <safety>
-- LinkedIn operations here are read-only fetches plus adding rows to a campaign table. **No messages are generated, approved, or sent by this skill.**
+- LinkedIn operations here are read-only fetches plus a typed product import into a campaign table. **No messages are generated, approved, scheduled, or sent by this skill.**
 - Respect workspace boundaries: only add leads to campaigns in the active workspace, and only for senders that belong to it.
 - Respect campaign boundaries: only add engagers to the matched sender-owned Post Engagers campaign/table. Do not mix shared-lane engagers into sender-owned campaigns or sender-owned engagers into shared lanes.
 - Cap provider usage per run: at most 5 posts × `fetch_post_engagers` per sender. If the invoking automation wants more, it must say so explicitly.
-- Never call `start_campaign`, `attach_sequence`, `queue_campaign_cells`, `start_campaign_message_preparation`, approval tools, or any send/schedule tool.
+- Never call `start_campaign`, `attach_sequence`, `queue_campaign_cells`, `start_campaign_message_preparation`, approval tools, send/schedule tools, or shared-lane mutation tools.
+- Never create campaigns, change campaign status, change sender ownership, approve campaign cells, or start message prep as part of this refresh.
 </safety>
 
 <output>