@sellable/install 0.1.312 → 0.1.314

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",
@@ -89,7 +97,7 @@ export const CREATE_CAMPAIGN_SMOKE_CALLS = [
     arguments: {
       subskillName: "create-evergreen-campaigns",
       offset: 0,
-      limit: 4000,
+      limit: CONNECTION_ONLY_EVERGREEN_PROMPT_CHUNK_LIMIT,
     },
   },
   {
@@ -195,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);
@@ -239,15 +284,24 @@ 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"
-          ? prompt.includes('campaignSequenceOptions:{ mode:"connection_only" }') &&
-            prompt.includes('templateRef:"connection_only"') &&
-            prompt.includes('sequenceReceipt.actionTypes:["send_invite"]')
+          ? summarizeConnectionOnlyEvergreenProofs(
+              connectionOnlyEvergreenProofs
+            ).ok
           : null,
       hasMore: parsed.hasMore === true,
       nextOffset:
@@ -282,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 {
@@ -295,76 +350,158 @@ 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) {
-        return {
+
+        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,
-          missingTools: [],
-          calls,
-          error: `${call.name} returned an MCP tool error`,
-          startedAt,
+          summary: null,
+          error: redact(error),
+          startedAt: callStartedAt,
           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",
+          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(),

package/package.json

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

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

@@ -854,11 +854,11 @@ not a parent-thread summary. The receipt must include:
   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
-  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
+  `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
   `finalPausedSendProof.currentStep` and
   `finalPausedSendProof.campaignStatus`.
 - `verifyCall`: the exact `setup_evergreen_campaigns({ mode:"verify",