@sellable/mcp 0.1.136 → 0.1.138

package/agents/post-find-leads-filter-scout.md

@@ -1,7 +1,7 @@
 You are Lead Fit Builder for Sellable create-campaign-v2.
 
-Your job starts only after find-leads has produced `lead-review.md` and
-`lead-sample.json`, and the lead source has been approved or auto-confirmed.
+Your job starts only after the lead source has been approved or auto-confirmed
+and the bounded review batch exists in the campaign table.
 Work only on the lead filter branch. Do not source new leads, draft messages,
 import leads, create campaigns, or ask the user questions. Your only live
 campaign mutation is calling `save_rubrics` after the production rubrics are
@@ -9,41 +9,38 @@ ready.
 
 Required inputs:
 
-- `brief.md`
-- `lead-review.md`
-- `lead-sample.json`
-- campaign state from the parent thread
-- campaign table sample from the parent thread
+- `campaignId`
+- campaign revision or `campaignUpdatedAt`
+- campaign brief content
+- selected source decision and provider/list state
+- `selectedLeadListId`
+- `workflowTableId`
+- imported review-batch rows, including row ids/hash when available
+- filter choice
 
 Required first steps:
 
-1. Read the three required inputs.
-2. Load the filter-leads reference before writing artifacts:
+1. Verify the campaign/source/table ids from the parent thread match the live
+   campaign context.
+2. Load the filter-leads reference before designing rubrics:
    `get_subskill_asset({ subskillName: "create-campaign-v2", assetPath: "references/filter-leads.md" })`.
 3. Treat campaign state and the campaign table sample as the input of record.
-   Disk files are context/debug aids, not durable state.
+   Do not require or hunt for local markdown/json artifacts.
 
 Owned outputs:
 
 - Durable campaign rubrics via `save_rubrics({ campaignOfferId, leadScoringRubrics })`
   when the filter is confirmed and production-shaped rubrics are safe to write.
   `save_rubrics` is the durable writer.
-- `lead-filter.md` debug artifact after the durable campaign write
-- `rubric.json` debug artifact after the durable campaign write
+- concise filter/rubric summary returned to the parent thread
 
-Do not write or modify:
-
-- `message-validation.md`
-- `message-review.md`
-- `approval-packet.md`
-- `brief.md`
-- `lead-review.md`
-- `lead-sample.json`
+Do not write or modify local markdown/json artifacts. Durable output is only
+via `save_rubrics` plus the parent-thread summary.
 
 Process:
 
-1. Preserve the approved source decision and the sample math from
-   `lead-review.md`; do not re-run sourcing.
+1. Preserve the approved source decision and review-batch sample math supplied
+   by the parent; do not re-run sourcing.
 2. Turn the sample's good-fit and false-positive patterns into a strict but
    campaign-native filter.
 3. Include keep rules, exclude rules, sample false positives, pass-rate /
@@ -56,14 +53,11 @@ Process:
 6. If status is `confirmed`, call `save_rubrics` with 2-5 production-shaped
    active `leadScoringRubrics` before reporting success. If `save_rubrics`
    fails, stop and report the blocker; do not claim the filter is persisted.
-7. Write `lead-filter.md` and `rubric.json` only as debug artifacts after
-   campaign persistence succeeds.
 
 Return a concise final status with:
 
 - filter status: `confirmed`, `confirm-with-user`, or `revise-find-leads`
 - whether `save_rubrics` succeeded and how many active rubrics were persisted
-- artifacts written
 - strongest keep rules
 - strongest exclusion rules
 - expected pass-rate / yield impact

package/agents/post-find-leads-message-scout.md

@@ -80,6 +80,27 @@ When reporting branch runtime proof, use this shape under
 Do not tell the UI to show Message Draft Builder as running unless this proof
 exists and points at the current non-empty bounded review batch.
 
+## Basis Changes And Rewrites
+
+The first completed recommendation is the default message review candidate.
+Do not automatically retry or regenerate only because Lead Fit Builder finished,
+rubrics were saved, Filter Leads completed, enrichment cells populated, or more
+row data became available after this branch started.
+
+Treat later filter/enrichment data as optional rewrite context. If campaign id,
+brief hash, selected source, `selectedLeadListId`, `workflowTableId`, and
+review-batch row ids/hash still match, keep the initial recommendation usable
+and report `status: ready` with `basisStatus: "usable_initial"` or
+`"enriched_rewrite_available"`. The parent thread may offer the user a choice
+to keep the initial draft or rewrite with enriched/filter data, but the rewrite
+must be explicit user opt-in.
+
+Retry or regenerate without asking only when the initial recommendation is
+missing, failed, structurally invalid, unsafe, or mismatched on campaign id,
+brief hash, selected source, `selectedLeadListId`, `workflowTableId`, or
+review-batch rows. Filter/rubric/enrichment basis drift alone is not a stale
+blocker.
+
 ## Hard Rules
 
 - Do not call product Generate Message cells. This worker drafts the template

package/agents/registry.json

@@ -158,22 +158,20 @@
       "displayName": "Lead Fit Builder",
       "target": "filter-leads",
       "inputs": [
-        "brief.md",
-        "lead-review.md",
-        "lead-sample.json"
-      ],
-      "producesArtifacts": [
-        "lead-filter.md"
-      ],
-      "optionalProducesArtifacts": [
-        "rubric.json"
+        "campaignId",
+        "campaignBrief",
+        "source decision and selectedLeadList/source state",
+        "workflowTableId",
+        "imported review-batch rows"
       ],
+      "producesArtifacts": [],
+      "optionalProducesArtifacts": [],
       "ownership": "lead quality, false-positive patterns, keep/exclude rules, ability-to-pay checks, and production rubric translation only",
       "codex": {
         "description": "Lead Fit Builder for campaign-backed lead filtering and rubric persistence after source approval.",
         "model": "gpt-5.5",
         "modelReasoningEffort": "high",
-        "sandboxMode": "workspace-write",
+        "sandboxMode": "read-only",
         "nicknameCandidates": [
           "Lead Fit Builder",
           "Fit Builder",
@@ -181,17 +179,12 @@
         ]
       },
       "claude": {
-        "description": "Use proactively as Lead Fit Builder after lead source approval to persist campaign rubrics and write lead-filter debug artifacts from campaign state.",
+        "description": "Use proactively as Lead Fit Builder after lead source approval to persist campaign rubrics from campaign state.",
         "model": "inherit",
         "background": true,
         "maxTurns": 8,
         "color": "yellow",
         "tools": [
-          "Read",
-          "Write",
-          "Edit",
-          "Grep",
-          "Glob",
           "mcp__sellable__get_subskill_prompt",
           "mcp__sellable__get_subskill_asset",
           "mcp__sellable__save_rubrics"

package/agents/source-scout-linkedin-engagement.md

@@ -9,8 +9,8 @@ Required first step:
 "signal-discovery", campaignOfferId, confirmed: true })` and include that same
   `campaignOfferId` plus `currentStep: "signal-discovery"` in `search_signals`
   so the owning search route can show the source lane with current find-leads
-  narration and user options. Treat that as a campaign-attached persisted
-  search; do not run a post-mint search without the campaign ID. If no campaign
+  narration and user options. Treat that as a campaign-attached persisted search;
+  do not run a post-mint search without the campaign ID. If no campaign
   ID is supplied, run campaignless preview mode.
 
 Use the inherited Sellable MCP tools when available:

package/dist/engage-memory.d.ts

@@ -1,3 +1,4 @@
+import { type IdentityMemoryChunk, type IdentityMemoryDirectory } from "./identity-memory.js";
 export interface EngageStyleGuide {
     markdown: string;
     updatedAt: string;
@@ -20,6 +21,18 @@ export interface EngageMemory {
     styleGuide?: EngageStyleGuide;
     provenSearches: ProvenSearch[];
     trackedPeople: TrackedPerson[];
+    identity?: IdentityMemoryChunk;
+    company?: IdentityMemoryChunk;
+    antiAiStyle?: IdentityMemoryChunk;
+    proofLedger?: IdentityMemoryChunk;
+    winsLedger?: IdentityMemoryChunk;
+    storyBank?: IdentityMemoryChunk;
+    answerBank?: IdentityMemoryChunk;
+    contextModes?: IdentityMemoryChunk;
+    decisionRules?: IdentityMemoryChunk;
+    changeLog?: IdentityMemoryChunk;
+    transcripts?: IdentityMemoryDirectory;
+    references?: IdentityMemoryDirectory;
 }
 /** Check if a sender has per-sender config directory. */
 export declare function senderHasConfig(senderId: string): boolean;

package/dist/engage-memory.js

@@ -1,5 +1,7 @@
 import * as fs from "fs";
+import * as os from "os";
 import * as path from "path";
+import { readIdentityMemory, } from "./identity-memory.js";
 // ── Config directory resolution ────────────────────────────────────────────
 function resolveConfigsDir() {
     const candidates = [];
@@ -11,6 +13,7 @@ function resolveConfigsDir() {
         candidates.push(path.resolve(path.dirname(process.argv[1]), "../../.sellable/configs"));
     }
     candidates.push(path.resolve(process.cwd(), ".sellable/configs"));
+    candidates.push(path.resolve(os.homedir(), ".sellable/configs"));
     for (const candidate of candidates) {
         if (fs.existsSync(candidate)) {
             return candidate;
@@ -44,22 +47,21 @@ function writeFile(relPath, content) {
     fs.writeFileSync(fullPath, content);
 }
 // ── Sender-scoped path resolution ─────────────────────────────────────────
-/** Per-sender file paths. When senderId is given, resolves to senders/{id}/file.
- *  Falls back to legacy flat path when senderId is omitted or sender dir doesn't exist. */
+/** Per-sender reads fall back by file so partial sender dirs do not hide flat memory. */
 function senderPath(senderId, fileName, flatFallback) {
     if (senderId) {
-        const senderDir = `senders/${senderId}`;
-        const senderFile = `${senderDir}/${fileName}`;
-        // If sender dir exists, always use it (even if file doesn't exist yet — it'll be created)
-        if (fs.existsSync(path.join(getConfigsDir(), senderDir))) {
-            return senderFile;
-        }
-        // If the file exists in sender dir (dir just created), use it
+        const senderFile = `senders/${senderId}/${fileName}`;
         if (fs.existsSync(path.join(getConfigsDir(), senderFile))) {
             return senderFile;
         }
     }
-    // Fallback to flat path
+    return flatFallback;
+}
+/** Per-sender writes are deterministic when a sender ID is supplied. */
+function senderWritePath(senderId, fileName, flatFallback) {
+    if (senderId) {
+        return `senders/${senderId}/${fileName}`;
+    }
     return flatFallback;
 }
 /** Check if a sender has per-sender config directory. */
@@ -119,39 +121,132 @@ function buildMarkdownTable(headers, rows) {
 // ── Style guide ────────────────────────────────────────────────────────────
 const FLAT_STYLE_CORE_PATH = "writing/styleguide-core.md";
 const STYLE_COMMENTS_PATH = "writing/comments.md";
-function readStyleGuide(senderId) {
+const LEGACY_AUDIENCE_ICP_PATH = "audience/icp.md";
+const LEGACY_FAQS_CORE_PATH = "faqs/core.md";
+function readStyleGuide(senderId, identityMemory) {
     const corePath = senderPath(senderId, "styleguide-core.md", FLAT_STYLE_CORE_PATH);
     const core = readFile(corePath);
     // comments.md is always shared
     const comments = readFile(STYLE_COMMENTS_PATH);
-    if (!core && !comments)
-        return undefined;
+    if (!hasCoreIdentityMemory(identityMemory)) {
+        if (!core && !comments)
+            return undefined;
+        const legacyParts = [];
+        if (core)
+            legacyParts.push(core.trim());
+        if (comments)
+            legacyParts.push(comments.trim());
+        return {
+            markdown: legacyParts.join("\n\n"),
+            updatedAt: latestUpdatedAt([corePath, STYLE_COMMENTS_PATH]),
+        };
+    }
     const parts = [];
-    if (core)
-        parts.push(core.trim());
-    if (comments)
-        parts.push(comments.trim());
-    const markdown = parts.join("\n\n");
-    // Use file mtime as updatedAt
-    const coreFullPath = path.join(getConfigsDir(), corePath);
-    const commentsFullPath = path.join(getConfigsDir(), STYLE_COMMENTS_PATH);
-    const coreMtime = fs.existsSync(coreFullPath)
-        ? fs.statSync(coreFullPath).mtime
-        : new Date(0);
-    const commentsMtime = fs.existsSync(commentsFullPath)
-        ? fs.statSync(commentsFullPath).mtime
-        : new Date(0);
-    const updatedAt = new Date(Math.max(coreMtime.getTime(), commentsMtime.getTime())).toISOString();
-    return { markdown, updatedAt };
+    const sourcePaths = [];
+    parts.push("# Sellable Core Identity Memory");
+    appendCoreSection(parts, sourcePaths, "Core Identity", identityMemory.identity);
+    appendCoreSection(parts, sourcePaths, "Core Company", identityMemory.company);
+    appendCoreSection(parts, sourcePaths, "Core Anti-AI Writing Style", identityMemory.antiAiStyle);
+    appendCoreSection(parts, sourcePaths, "Core Proof Ledger", identityMemory.proofLedger);
+    appendCoreSection(parts, sourcePaths, "Core Wins Ledger", identityMemory.winsLedger);
+    appendCoreSection(parts, sourcePaths, "Core Story Bank", identityMemory.storyBank);
+    appendCoreSection(parts, sourcePaths, "Core Answer Bank", identityMemory.answerBank);
+    appendCoreSection(parts, sourcePaths, "Core Context Modes", identityMemory.contextModes);
+    appendCoreSection(parts, sourcePaths, "Core Decision Rules", identityMemory.decisionRules);
+    appendCoreSection(parts, sourcePaths, "Core Change Log", identityMemory.changeLog);
+    appendCoreDirectoryIndex(parts, sourcePaths, "Core Transcripts Index", identityMemory.transcripts);
+    appendCoreDirectoryIndex(parts, sourcePaths, "Core References Index", identityMemory.references);
+    if (core) {
+        appendCompatibilitySection(parts, sourcePaths, {
+            title: senderId
+                ? "Legacy Compatibility: Connected Sender Style Guide"
+                : "Legacy Compatibility: Style Guide",
+            relativePath: corePath,
+            markdown: core,
+        });
+    }
+    if (comments) {
+        appendCompatibilitySection(parts, sourcePaths, {
+            title: "Legacy Compatibility: Comment Rules",
+            relativePath: STYLE_COMMENTS_PATH,
+            markdown: comments,
+        });
+    }
+    const legacyAudienceIcp = readFile(LEGACY_AUDIENCE_ICP_PATH);
+    if (!identityMemory.company && legacyAudienceIcp) {
+        appendCompatibilitySection(parts, sourcePaths, {
+            title: "Legacy Compatibility: Audience ICP",
+            relativePath: LEGACY_AUDIENCE_ICP_PATH,
+            markdown: legacyAudienceIcp,
+        });
+    }
+    const legacyFaqsCore = readFile(LEGACY_FAQS_CORE_PATH);
+    if (!identityMemory.proofLedger && legacyFaqsCore) {
+        appendCompatibilitySection(parts, sourcePaths, {
+            title: "Legacy Compatibility: FAQ Proof",
+            relativePath: LEGACY_FAQS_CORE_PATH,
+            markdown: legacyFaqsCore,
+        });
+    }
+    return {
+        markdown: parts.join("\n\n"),
+        updatedAt: latestUpdatedAt(sourcePaths),
+    };
+}
+function hasCoreIdentityMemory(identityMemory) {
+    return Boolean(identityMemory.identity ||
+        identityMemory.company ||
+        identityMemory.antiAiStyle ||
+        identityMemory.proofLedger ||
+        identityMemory.winsLedger ||
+        identityMemory.storyBank ||
+        identityMemory.answerBank ||
+        identityMemory.contextModes ||
+        identityMemory.decisionRules ||
+        identityMemory.changeLog ||
+        identityMemory.transcripts?.index ||
+        identityMemory.references?.index);
+}
+function appendCoreSection(parts, sourcePaths, title, chunk) {
+    if (!chunk)
+        return;
+    parts.push(`## ${title}: ${chunk.source.relativePath}\n\n${chunk.markdown.trim()}`);
+    sourcePaths.push(chunk.source.relativePath);
+}
+function appendCoreDirectoryIndex(parts, sourcePaths, title, directory) {
+    if (!directory?.index)
+        return;
+    appendCoreSection(parts, sourcePaths, title, directory.index);
+}
+function appendCompatibilitySection(parts, sourcePaths, section) {
+    parts.push(`## ${section.title} (${section.relativePath})\n\n${section.markdown.trim()}`);
+    sourcePaths.push(section.relativePath);
+}
+function latestUpdatedAt(relativePaths) {
+    const latest = relativePaths.reduce((max, relativePath) => {
+        const fullPath = path.join(getConfigsDir(), relativePath);
+        if (!fs.existsSync(fullPath))
+            return max;
+        return Math.max(max, fs.statSync(fullPath).mtime.getTime());
+    }, 0);
+    return new Date(latest).toISOString();
 }
 export function getEngageMemory(senderId) {
-    const styleGuide = readStyleGuide(senderId);
+    const identityMemory = readIdentityMemory({ connectedSenderId: senderId });
+    const styleGuide = readStyleGuide(senderId, identityMemory);
     const provenSearches = readProvenSearches(senderId);
     const trackedPeople = readTrackedPeople(senderId);
-    return { memory: { styleGuide, provenSearches, trackedPeople } };
+    return {
+        memory: {
+            styleGuide,
+            provenSearches,
+            trackedPeople,
+            ...identityMemory,
+        },
+    };
 }
 export function setStyleGuide(markdown, senderId) {
-    const corePath = senderPath(senderId, "styleguide-core.md", FLAT_STYLE_CORE_PATH);
+    const corePath = senderWritePath(senderId, "styleguide-core.md", FLAT_STYLE_CORE_PATH);
     writeFile(corePath, markdown + "\n");
     const updatedAt = new Date().toISOString();
     return { styleGuide: { markdown, updatedAt } };
@@ -202,7 +297,7 @@ function writeProvenSearches(searches, senderId) {
         Yielded: String(s.totalYielded),
         "Hit Rate": s.avgHitRate.toFixed(2),
     }));
-    const filePath = senderPath(senderId, "proven-searches.md", FLAT_PROVEN_SEARCHES_PATH);
+    const filePath = senderWritePath(senderId, "proven-searches.md", FLAT_PROVEN_SEARCHES_PATH);
     const table = buildMarkdownTable(PROVEN_HEADERS, rows);
     writeFile(filePath, PROVEN_SEARCHES_HEADER + table + "\n");
 }
@@ -251,7 +346,7 @@ const INFLUENCER_HEADERS = [
     "Include in Discovery",
 ];
 function readTrackedPeople(senderId) {
-    const filePath = senderPath(senderId, "influencers.md", FLAT_INFLUENCERS_PATH);
+    const filePath = senderWritePath(senderId, "influencers.md", FLAT_INFLUENCERS_PATH);
     const content = readFile(filePath);
     if (!content)
         return [];

package/dist/identity-compiler.d.ts

@@ -0,0 +1,119 @@
+export interface IdentityGeneratedSectionProposal {
+    relativePath: string;
+    key: string;
+    markdown: string;
+}
+export interface IdentityProofEntryProposal {
+    key?: string;
+    claim: string;
+    source?: string;
+    confidence?: string;
+    allowedUse?: string;
+    privacy?: string;
+    notes?: string;
+}
+export interface IdentityWinEntryProposal {
+    key?: string;
+    title: string;
+    proofType?: string;
+    outcome?: string;
+    source?: string;
+    permission?: string;
+    confidence?: string;
+    publicSafety?: string;
+    allowedUse?: string;
+    notes?: string;
+}
+export interface IdentityStoryEntryProposal {
+    key?: string;
+    title: string;
+    setup?: string;
+    moment?: string;
+    lesson?: string;
+    source?: string;
+    contexts?: string;
+    privacy?: string;
+    notes?: string;
+}
+export interface IdentityAnswerEntryProposal {
+    key?: string;
+    question: string;
+    answer: string;
+    topicTags?: string;
+    source?: string;
+    useContexts?: string;
+    confidence?: string;
+    privacy?: string;
+    derivedMemoryLinks?: string;
+}
+export interface IdentityRuleEntryProposal {
+    key?: string;
+    title: string;
+    rule: string;
+    source?: string;
+}
+export interface IdentityAntiAiBanProposal {
+    key?: string;
+    pattern: string;
+    rule: string;
+    context?: string;
+    source?: string;
+}
+export interface IdentityChangeLogEntryProposal {
+    key?: string;
+    date: string;
+    source?: string;
+    changed: string;
+    newRule: string;
+}
+export interface IdentityTranscriptIndexRowProposal {
+    key?: string;
+    title: string;
+    sourcePath: string;
+    date?: string;
+    speakers?: string;
+    targetSpeaker?: string;
+    topics?: string;
+    contextMode?: string;
+    sampleType?: string;
+    sensitivity?: string;
+}
+export interface IdentityTopicTranscriptProposal {
+    key?: string;
+    topicSlug: string;
+    title: string;
+    sourcePath: string;
+    targetSpeaker?: string;
+    excerpt: string;
+}
+export interface IdentityReferenceRowProposal {
+    key?: string;
+    category?: string;
+    indexPath?: string;
+    title: string;
+    source: string;
+    copiedPath?: string;
+    tags?: string;
+    whyItMatters?: string;
+    usageContexts?: string;
+    lastReviewed?: string;
+}
+export interface IdentityCompilerProposal {
+    configsDir?: string;
+    generatedSections?: IdentityGeneratedSectionProposal[];
+    proofEntries?: IdentityProofEntryProposal[];
+    winsEntries?: IdentityWinEntryProposal[];
+    storyEntries?: IdentityStoryEntryProposal[];
+    answerEntries?: IdentityAnswerEntryProposal[];
+    decisionRules?: IdentityRuleEntryProposal[];
+    antiAiBans?: IdentityAntiAiBanProposal[];
+    changeLogEntries?: IdentityChangeLogEntryProposal[];
+    transcriptIndexRows?: IdentityTranscriptIndexRowProposal[];
+    topicTranscripts?: IdentityTopicTranscriptProposal[];
+    referenceRows?: IdentityReferenceRowProposal[];
+}
+export interface IdentityCompilerResult {
+    configsDir: string;
+    filesChanged: string[];
+}
+export declare function applyIdentityCompilerProposal(proposal: IdentityCompilerProposal): IdentityCompilerResult;