@sellable/mcp 0.1.136 → 0.1.138

package/dist/identity-compiler.js

@@ -0,0 +1,344 @@
+import * as fs from "fs";
+import * as path from "path";
+import { CORE_MEMORY_PATHS, resolveIdentityConfigsDir, } from "./identity-memory.js";
+export function applyIdentityCompilerProposal(proposal) {
+    const configsDir = proposal.configsDir ?? resolveIdentityConfigsDir();
+    const changed = new Set();
+    for (const section of proposal.generatedSections ?? []) {
+        if (upsertGeneratedSection(configsDir, section.relativePath, section.key, section.markdown)) {
+            changed.add(section.relativePath);
+        }
+    }
+    upsertBlockEntries(configsDir, CORE_MEMORY_PATHS.proofLedger, "Proof Ledger", proposal.proofEntries, (entry) => stableKey("proof", [entry.key, entry.claim, entry.source]).toLowerCase(), (entry) => renderBlock(`Claim: ${entry.claim.trim()}`, {
+        Source: entry.source,
+        Confidence: entry.confidence,
+        "Allowed use": entry.allowedUse,
+        Privacy: entry.privacy,
+        Notes: entry.notes,
+    }), changed);
+    upsertBlockEntries(configsDir, CORE_MEMORY_PATHS.winsLedger, "Wins Ledger", proposal.winsEntries, (entry) => stableKey("win", [entry.key, entry.title, entry.source]), (entry) => renderBlock(`Win: ${entry.title.trim()}`, {
+        "Proof type": entry.proofType,
+        Outcome: entry.outcome,
+        Source: entry.source,
+        Permission: entry.permission,
+        Confidence: entry.confidence,
+        "Public/private safety": entry.publicSafety,
+        "Allowed use": entry.allowedUse,
+        Notes: entry.notes,
+    }), changed);
+    upsertBlockEntries(configsDir, CORE_MEMORY_PATHS.storyBank, "Story Bank", proposal.storyEntries, (entry) => stableKey("story", [entry.key, entry.title, entry.source]), (entry) => renderBlock(`Story: ${entry.title.trim()}`, {
+        Setup: entry.setup,
+        Moment: entry.moment,
+        Lesson: entry.lesson,
+        Source: entry.source,
+        Contexts: entry.contexts,
+        Privacy: entry.privacy,
+        Notes: entry.notes,
+    }), changed);
+    upsertBlockEntries(configsDir, CORE_MEMORY_PATHS.answerBank, "Answer Bank", proposal.answerEntries, (entry) => stableKey("answer", [
+        entry.key,
+        entry.question,
+        entry.topicTags,
+        entry.source,
+    ]), (entry) => renderBlock(`Question: ${entry.question.trim()}`, {
+        Answer: entry.answer,
+        Topics: entry.topicTags,
+        Source: entry.source,
+        "Use contexts": entry.useContexts,
+        Confidence: entry.confidence,
+        Privacy: entry.privacy,
+        "Derived memory links": entry.derivedMemoryLinks,
+    }), changed);
+    upsertBlockEntries(configsDir, CORE_MEMORY_PATHS.decisionRules, "Decision Rules", proposal.decisionRules, (entry) => stableKey("rule", [entry.key, entry.title, entry.source]), (entry) => renderBlock(`Rule: ${entry.title.trim()}`, {
+        Rule: entry.rule,
+        Source: entry.source,
+    }), changed);
+    upsertBlockEntries(configsDir, CORE_MEMORY_PATHS.antiAiStyle, "Anti-AI Writing Style", proposal.antiAiBans, (entry) => stableKey("anti-ai", [entry.key, entry.pattern, entry.context]), (entry) => renderBlock(`Banned Pattern: ${entry.pattern.trim()}`, {
+        Rule: entry.rule,
+        Context: entry.context,
+        Source: entry.source,
+    }), changed);
+    upsertBlockEntries(configsDir, CORE_MEMORY_PATHS.changeLog, "Change Log", proposal.changeLogEntries, (entry) => stableKey("change", [entry.key, entry.date, entry.changed, entry.source]), (entry) => renderBlock(`Change: ${entry.date} - ${entry.changed.trim()}`, {
+        Source: entry.source,
+        "New rule": entry.newRule,
+    }), changed);
+    if (upsertTableRows(configsDir, "core/transcripts/INDEX.md", "Transcript Index", [
+        "Title",
+        "Source",
+        "Date",
+        "Speakers",
+        "Target Speaker",
+        "Topics",
+        "Context Mode",
+        "Sample Type",
+        "Sensitivity",
+        "Key",
+    ], (proposal.transcriptIndexRows ?? []).map((row) => {
+        const key = stableKey("transcript", [
+            row.key,
+            row.sourcePath,
+            row.date,
+            row.targetSpeaker,
+            row.topics,
+            row.title,
+        ]);
+        return {
+            key,
+            row: {
+                Title: row.title,
+                Source: row.sourcePath,
+                Date: row.date ?? "",
+                Speakers: row.speakers ?? "",
+                "Target Speaker": row.targetSpeaker ?? "",
+                Topics: row.topics ?? "",
+                "Context Mode": row.contextMode ?? "",
+                "Sample Type": row.sampleType ?? "",
+                Sensitivity: row.sensitivity ?? "",
+                Key: key,
+            },
+        };
+    }))) {
+        changed.add("core/transcripts/INDEX.md");
+    }
+    for (const topic of proposal.topicTranscripts ?? []) {
+        const topicSlug = normalizeSlug(topic.topicSlug);
+        const relativePath = `core/transcripts/topics/${topicSlug}.md`;
+        const key = stableKey("topic", [
+            topic.key,
+            topicSlug,
+            topic.sourcePath,
+            topic.targetSpeaker,
+            topic.title,
+        ]);
+        const block = renderBlock(`Transcript: ${topic.title.trim()}`, {
+            Source: topic.sourcePath,
+            "Target speaker": topic.targetSpeaker,
+            Excerpt: topic.excerpt,
+        });
+        if (upsertGeneratedSection(configsDir, relativePath, key, block, "Topic Transcript")) {
+            changed.add(relativePath);
+        }
+    }
+    const referenceRowsByPath = new Map();
+    for (const reference of proposal.referenceRows ?? []) {
+        const relativePath = reference.indexPath ??
+            `core/references/${normalizeSlug(reference.category ?? "misc")}/INDEX.md`;
+        const key = stableKey("reference", [
+            reference.key,
+            reference.source,
+            reference.title,
+            reference.copiedPath,
+        ]);
+        const rows = referenceRowsByPath.get(relativePath) ?? [];
+        rows.push({
+            key,
+            row: {
+                Title: reference.title,
+                "Source Path/URL": reference.source,
+                "Copied Path": reference.copiedPath ?? "indexed only",
+                Tags: reference.tags ?? "",
+                "Why It Matters": reference.whyItMatters ?? "",
+                "Usage Contexts": reference.usageContexts ?? "",
+                "Last Reviewed": reference.lastReviewed ?? "",
+                Key: key,
+            },
+        });
+        referenceRowsByPath.set(relativePath, rows);
+    }
+    for (const [relativePath, rows] of referenceRowsByPath) {
+        if (upsertTableRows(configsDir, relativePath, "Reference Index", [
+            "Title",
+            "Source Path/URL",
+            "Copied Path",
+            "Tags",
+            "Why It Matters",
+            "Usage Contexts",
+            "Last Reviewed",
+            "Key",
+        ], rows)) {
+            changed.add(relativePath);
+        }
+    }
+    return {
+        configsDir,
+        filesChanged: [...changed].sort(),
+    };
+}
+function upsertBlockEntries(configsDir, relativePath, title, entries, keyForEntry, markdownForEntry, changed) {
+    if (!entries?.length)
+        return;
+    const seen = new Set();
+    let fileChanged = false;
+    for (const entry of entries) {
+        const key = keyForEntry(entry);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        fileChanged =
+            upsertGeneratedSection(configsDir, relativePath, key, markdownForEntry(entry), title) || fileChanged;
+    }
+    if (fileChanged) {
+        changed.add(relativePath);
+    }
+}
+function upsertGeneratedSection(configsDir, relativePath, key, markdown, defaultTitle) {
+    const cleanKey = key.trim();
+    const filePath = resolveConfigPath(configsDir, relativePath);
+    const existing = readMarkdown(filePath);
+    const base = existing || (defaultTitle ? `# ${defaultTitle}\n` : "");
+    const block = generatedBlock(cleanKey, markdown);
+    const blockPattern = new RegExp(`${escapeRegExp(startMarker(cleanKey))}\\n[\\s\\S]*?\\n${escapeRegExp(END_MARKER)}`, "m");
+    const next = blockPattern.test(base)
+        ? base.replace(blockPattern, block)
+        : appendMarkdown(base, block);
+    return writeMarkdownIfChanged(filePath, next);
+}
+function upsertTableRows(configsDir, relativePath, title, headers, rows) {
+    if (rows.length === 0)
+        return false;
+    const filePath = resolveConfigPath(configsDir, relativePath);
+    const existing = readMarkdown(filePath) || `# ${title}\n`;
+    const table = parseFirstMarkdownTable(existing);
+    const existingRows = table ? table.rows : [];
+    const rowByKey = new Map();
+    for (const row of existingRows) {
+        const key = row.Key ||
+            stableKey("row", headers.map((header) => row[header] ?? ""));
+        rowByKey.set(key, row);
+    }
+    const seenInputKeys = new Set();
+    for (const { key, row } of rows) {
+        if (seenInputKeys.has(key))
+            continue;
+        seenInputKeys.add(key);
+        rowByKey.set(key, row);
+    }
+    const nextTable = buildMarkdownTable(headers, [...rowByKey.values()]);
+    const next = table
+        ? `${existing.slice(0, table.start)}${nextTable}${existing.slice(table.end)}`
+        : appendMarkdown(existing, nextTable);
+    return writeMarkdownIfChanged(filePath, next);
+}
+const END_MARKER = "<!-- sellable:generated:end -->";
+function startMarker(key) {
+    return `<!-- sellable:generated:start key="${key}" -->`;
+}
+function generatedBlock(key, markdown) {
+    return `${startMarker(key)}\n${markdown.trim()}\n${END_MARKER}`;
+}
+function renderBlock(title, fields) {
+    const lines = [`## ${title.trim()}`];
+    for (const [label, value] of Object.entries(fields)) {
+        const cleanValue = value?.trim();
+        if (!cleanValue)
+            continue;
+        lines.push(`- ${label}: ${cleanValue}`);
+    }
+    return lines.join("\n");
+}
+function parseFirstMarkdownTable(markdown) {
+    const lines = markdown.split(/\n/);
+    let offset = 0;
+    for (let index = 0; index < lines.length - 1; index++) {
+        const line = lines[index];
+        const next = lines[index + 1];
+        if (isTableLine(line) && /^\|[\s\-:|]+\|$/.test(next.trim())) {
+            const headers = splitTableLine(line);
+            const rows = [];
+            let tableEndLine = index + 2;
+            for (; tableEndLine < lines.length; tableEndLine++) {
+                const rowLine = lines[tableEndLine];
+                if (!isTableLine(rowLine))
+                    break;
+                const cells = splitTableLine(rowLine);
+                const row = {};
+                headers.forEach((header, headerIndex) => {
+                    row[header] = cells[headerIndex] ?? "";
+                });
+                rows.push(row);
+            }
+            const start = offset;
+            const end = lines.slice(0, tableEndLine).join("\n").length;
+            return { start, end, headers, rows };
+        }
+        offset += line.length + 1;
+    }
+    return undefined;
+}
+function buildMarkdownTable(headers, rows) {
+    const header = `| ${headers.join(" | ")} |`;
+    const separator = `| ${headers.map(() => "---").join(" | ")} |`;
+    const body = rows.map((row) => `| ${headers.map((headerName) => tableCell(row[headerName])).join(" | ")} |`);
+    return [header, separator, ...body].join("\n");
+}
+function isTableLine(line) {
+    const trimmed = line.trim();
+    return trimmed.startsWith("|") && trimmed.endsWith("|");
+}
+function splitTableLine(line) {
+    return line
+        .trim()
+        .slice(1, -1)
+        .split("|")
+        .map((cell) => cell.trim());
+}
+function tableCell(value) {
+    return (value ?? "").replace(/\r?\n/g, " ").replace(/\|/g, "\\|").trim();
+}
+function readMarkdown(filePath) {
+    if (!fs.existsSync(filePath))
+        return "";
+    return fs.readFileSync(filePath, "utf-8");
+}
+function writeMarkdownIfChanged(filePath, markdown) {
+    const next = `${markdown.trimEnd()}\n`;
+    if (readMarkdown(filePath) === next)
+        return false;
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, next);
+    return true;
+}
+function appendMarkdown(existing, addition) {
+    const trimmedExisting = existing.trimEnd();
+    if (!trimmedExisting)
+        return addition;
+    return `${trimmedExisting}\n\n${addition}`;
+}
+function resolveConfigPath(configsDir, relativePath) {
+    const cleanRelativePath = relativePath.replace(/\\/g, "/").trim();
+    if (cleanRelativePath === "" ||
+        cleanRelativePath.startsWith("/") ||
+        cleanRelativePath.split("/").includes("..")) {
+        throw new Error(`Invalid identity compiler path: ${relativePath}`);
+    }
+    const root = path.resolve(configsDir);
+    const resolved = path.resolve(root, cleanRelativePath);
+    const relative = path.relative(root, resolved);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error(`Invalid identity compiler path: ${relativePath}`);
+    }
+    return resolved;
+}
+function stableKey(prefix, parts) {
+    const normalizedParts = parts
+        .filter((part) => Boolean(part?.trim()))
+        .map(normalizeKeyPart)
+        .filter(Boolean);
+    return `${normalizeKeyPart(prefix)}:${normalizedParts.join(":") || "entry"}`;
+}
+function normalizeSlug(value) {
+    return normalizeKeyPart(value) || "misc";
+}
+function normalizeKeyPart(value) {
+    return value
+        .normalize("NFKD")
+        .toLowerCase()
+        .replace(/['"]/g, "")
+        .replace(/https?:\/\//g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 120);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/identity-memory.d.ts

@@ -0,0 +1,49 @@
+export declare const CORE_MEMORY_PATHS: {
+    readonly identity: "core/about-me.md";
+    readonly company: "core/my-company.md";
+    readonly antiAiStyle: "core/anti-ai-writing-style.md";
+    readonly proofLedger: "core/proof-ledger.md";
+    readonly winsLedger: "core/wins-ledger.md";
+    readonly storyBank: "core/story-bank.md";
+    readonly answerBank: "core/answer-bank.md";
+    readonly contextModes: "core/context-modes.md";
+    readonly decisionRules: "core/decision-rules.md";
+    readonly changeLog: "core/change-log.md";
+    readonly transcripts: "core/transcripts";
+    readonly references: "core/references";
+};
+export interface IdentityMemorySource {
+    relativePath: string;
+    exists: boolean;
+}
+export interface IdentityMemoryChunk {
+    markdown: string;
+    source: IdentityMemorySource;
+}
+export interface IdentityMemoryDirectory {
+    source: IdentityMemorySource;
+    index?: IdentityMemoryChunk;
+}
+export interface IdentityMemory {
+    identity?: IdentityMemoryChunk;
+    company?: IdentityMemoryChunk;
+    antiAiStyle?: IdentityMemoryChunk;
+    proofLedger?: IdentityMemoryChunk;
+    winsLedger?: IdentityMemoryChunk;
+    storyBank?: IdentityMemoryChunk;
+    answerBank?: IdentityMemoryChunk;
+    contextModes?: IdentityMemoryChunk;
+    decisionRules?: IdentityMemoryChunk;
+    changeLog?: IdentityMemoryChunk;
+    transcripts?: IdentityMemoryDirectory;
+    references?: IdentityMemoryDirectory;
+}
+export interface ReadIdentityMemoryOptions {
+    /**
+     * Core identity/company memory is workspace-level in v1. Connected sender
+     * IDs remain engage compatibility overlays, not separate identity profiles.
+     */
+    connectedSenderId?: string;
+}
+export declare function resolveIdentityConfigsDir(): string;
+export declare function readIdentityMemory(_options?: ReadIdentityMemoryOptions): IdentityMemory;

package/dist/identity-memory.js

@@ -0,0 +1,89 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+export const CORE_MEMORY_PATHS = {
+    identity: "core/about-me.md",
+    company: "core/my-company.md",
+    antiAiStyle: "core/anti-ai-writing-style.md",
+    proofLedger: "core/proof-ledger.md",
+    winsLedger: "core/wins-ledger.md",
+    storyBank: "core/story-bank.md",
+    answerBank: "core/answer-bank.md",
+    contextModes: "core/context-modes.md",
+    decisionRules: "core/decision-rules.md",
+    changeLog: "core/change-log.md",
+    transcripts: "core/transcripts",
+    references: "core/references",
+};
+export function resolveIdentityConfigsDir() {
+    const candidates = [];
+    if (process.env.SELLABLE_CONFIGS_DIR) {
+        candidates.push(path.resolve(process.env.SELLABLE_CONFIGS_DIR));
+    }
+    if (process.argv[1]) {
+        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;
+        }
+    }
+    return candidates[candidates.length - 1];
+}
+export function readIdentityMemory(_options = {}) {
+    const configsDir = resolveIdentityConfigsDir();
+    const memory = {};
+    const fields = [
+        { key: "identity", relativePath: CORE_MEMORY_PATHS.identity },
+        { key: "company", relativePath: CORE_MEMORY_PATHS.company },
+        { key: "antiAiStyle", relativePath: CORE_MEMORY_PATHS.antiAiStyle },
+        { key: "proofLedger", relativePath: CORE_MEMORY_PATHS.proofLedger },
+        { key: "winsLedger", relativePath: CORE_MEMORY_PATHS.winsLedger },
+        { key: "storyBank", relativePath: CORE_MEMORY_PATHS.storyBank },
+        { key: "answerBank", relativePath: CORE_MEMORY_PATHS.answerBank },
+        { key: "contextModes", relativePath: CORE_MEMORY_PATHS.contextModes },
+        { key: "decisionRules", relativePath: CORE_MEMORY_PATHS.decisionRules },
+        { key: "changeLog", relativePath: CORE_MEMORY_PATHS.changeLog },
+    ];
+    for (const field of fields) {
+        const chunk = readMarkdownChunk(configsDir, field.relativePath);
+        if (chunk) {
+            memory[field.key] = chunk;
+        }
+    }
+    const transcripts = readDirectory(configsDir, CORE_MEMORY_PATHS.transcripts);
+    if (transcripts) {
+        memory.transcripts = transcripts;
+    }
+    const references = readDirectory(configsDir, CORE_MEMORY_PATHS.references);
+    if (references) {
+        memory.references = references;
+    }
+    return memory;
+}
+function readMarkdownChunk(configsDir, relativePath) {
+    const fullPath = path.join(configsDir, relativePath);
+    if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isFile()) {
+        return undefined;
+    }
+    return {
+        markdown: fs.readFileSync(fullPath, "utf-8"),
+        source: { relativePath, exists: true },
+    };
+}
+function readDirectory(configsDir, relativePath) {
+    const fullPath = path.join(configsDir, relativePath);
+    if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isDirectory()) {
+        return undefined;
+    }
+    const directory = {
+        source: { relativePath, exists: true },
+    };
+    const index = readMarkdownChunk(configsDir, `${relativePath}/INDEX.md`);
+    if (index) {
+        directory.index = index;
+    }
+    return directory;
+}

package/dist/tools/bootstrap.js

@@ -270,7 +270,7 @@ export async function bootstrapCreateCampaign(input = {}) {
         ? resumeDetected
             ? `Bootstrap complete.${workspaceNotice} Resume from campaign state and navigation diagnostics first; treat local draft artifacts as debug-only evidence. Then load ${createCampaignSubskill?.name ?? "create-campaign"} instructions with get_subskill_prompt({ subskillName: "${createCampaignSubskill?.name ?? "create-campaign"}" }); if the response has hasMore=true, continue with nextOffset until hasMore=false.`
             : flowVersion === "v2"
-                ? `Bootstrap complete.${workspaceNotice} Load create-campaign-v2 instructions with get_subskill_prompt({ subskillName: "create-campaign-v2" }); if the response has hasMore=true, continue with nextOffset until hasMore=false. Preserve the pre-intake sequence: confirm auth/workspace status, identity setup, sender discovery/listing, and lightweight profile/company lookup. Then run the short setup/intake, write the campaign brief, call create_campaign once to mint the watchable shell, surface the returned watch link, and hand off to lead finding.`
+                ? `Bootstrap complete.${workspaceNotice} Load the compact create-campaign-v2 entry prompt once with get_subskill_prompt({ subskillName: "create-campaign-v2" }); load flow/reference assets lazily only when that stage needs them. Preserve the pre-intake sequence: confirm auth/workspace status, resolve campaign identity, and run lightweight profile/company lookup. Do not call list_senders or sender discovery during setup; sender availability belongs only to Settings after message approval. Then run the short setup/intake, write the campaign brief, call create_campaign once to mint the watchable shell, surface the returned watch link, and hand off to lead finding.`
                 : `Bootstrap complete.${workspaceNotice} Load ${createCampaignSubskill?.name ?? "create-campaign"} instructions with get_subskill_prompt({ subskillName: "${createCampaignSubskill?.name ?? "create-campaign"}" }); if the response has hasMore=true, continue with nextOffset until hasMore=false. Follow that flow before calling create_campaign.`
         : "Bootstrap incomplete. Resolve blockingErrors and rerun bootstrap_create_campaign before provider/search/import tools.";
     // Strip prompt body from createCampaignSubskill — it's loaded via the host

package/dist/tools/engage-memory.js

@@ -2,13 +2,13 @@ import { copySenderConfig, getEngageMemory, migrateFlatConfigs, recordProvenSear
 export const engageMemoryToolDefinitions = [
     {
         name: "get_engage_memory",
-        description: "Load engage memory from .sellable/configs/: style guide, proven search keywords, and tracked people. All data lives in readable markdown files the user can also edit directly. When senderId is provided, reads from senders/{senderId}/ with flat-path fallback.",
+        description: "Load backward-compatible engage memory from .sellable/configs/: style guide, proven search keywords, tracked people, plus optional core identity/company memory. All data lives in readable markdown files the user can also edit directly. When senderId is provided, reads compatibility overrides from senders/{senderId}/ with flat-path fallback.",
         inputSchema: {
             type: "object",
             properties: {
                 senderId: {
                     type: "string",
-                    description: "Optional sender ID. When provided, reads per-sender configs from senders/{senderId}/. Falls back to flat configs if sender dir doesn't exist.",
+                    description: "Optional sender ID. When provided, reads per-sender compatibility configs from senders/{senderId}/. Falls back to flat configs for missing sender files.",
                 },
             },
             required: [],

package/dist/tools/navigation.js

@@ -243,6 +243,9 @@ function checkMessages(campaign) {
     if (!hasApprovedMessageTemplate(campaign)) {
         missing.push("approvedMessageTemplate");
     }
+    if (campaign.currentStep === "auto-execute-messaging") {
+        missing.push("generatedMessageReview");
+    }
     return { stepId: "messages", missing };
 }
 function checkSettings(campaign) {

package/dist/tools/prompts.d.ts

@@ -99,9 +99,7 @@ export interface SourceScoutRegistryResponse {
 export interface PostFindLeadsScoutRegistryResponse {
     version: number;
     trigger: "find_leads_source_approved";
-    requiredArtifacts?: string[];
     requiredInputs?: string[];
-    optionalDebugArtifacts?: string[];
     scouts: Array<{
         id: string;
         name: string;
@@ -125,11 +123,9 @@ export interface PostFindLeadsScoutRegistryResponse {
     }>;
     joinGate: {
         afterAllComplete: boolean;
-        requiredArtifacts?: string[];
         requiredState?: string[];
         noFilterRequiredState?: string[];
         skipFilterRule?: string;
-        optionalDebugArtifacts?: string[];
         show: string[];
         nextStage: string;
     };
@@ -140,6 +136,7 @@ export interface PostFindLeadsScoutRegistryResponse {
         runtimeProofRequiredFields: string[];
         basisFields: string[];
         compactOutputFields: string[];
+        reusePolicy?: string;
     };
     usage: {
         codex: string;

package/dist/tools/prompts.js

@@ -263,7 +263,6 @@ export function getPostFindLeadsScoutRegistry() {
             "imported review-batch rows from selectedLeadList with row ids/hash",
             "filter choice and filter/rubric basis when present",
         ],
-        optionalDebugArtifacts: ["brief.md", "lead-review.md", "lead-sample.json"],
         scouts: scouts.map((agent) => ({
             id: String(agent.id || ""),
             name: String(agent.name || ""),
@@ -294,7 +293,6 @@ export function getPostFindLeadsScoutRegistry() {
             requiredState: ["leadScoringRubrics", "messageDraftRecommendation"],
             noFilterRequiredState: ["messageDraftRecommendation"],
             skipFilterRule: "leadScoringRubrics may be absent only when the user explicitly skips filters with enableICPFilters=false; messageDraftRecommendation is still required before template review.",
-            optionalDebugArtifacts: ["lead-filter.md", "message-validation.md"],
             show: ["readable_filters_with_reasons", "sample_message_for_approval"],
             nextStage: "message-review",
         },
@@ -332,16 +330,18 @@ export function getPostFindLeadsScoutRegistry() {
                 "renderedSample",
                 "concerns",
                 "status",
+                "basisStatus",
                 "basisToken",
                 "outputAt",
                 "outputHash",
                 "error or retry detail",
             ],
+            reusePolicy: "The first completed Message Draft Builder recommendation remains the default review candidate. Later Lead Fit Builder, Filter Leads, enrichment, or rubric completion may make an enriched rewrite available, but does not automatically retry or replace the initial draft unless campaign/brief/source/list/table/review-batch identity mismatches or the initial output failed.",
         },
         usage: {
             codex: "After the user approves or auto-confirms the lead source, spawn both returned scout `name` values in one assistant turn only when the current Codex host exposes those custom agents.",
             claude: "After lead source approval, invoke both returned Task/Agent subagents in one assistant message only when the current Claude session lists those agents, so filter-leads and message generation run concurrently.",
-            parentThreadRule: "Named agents are optional acceleration. If they are absent, do not customer-surface install status; the main thread still orchestrates filter and message branches from CampaignOffer state, selected source state, workflowTableId, and imported review-batch rows. Debug markdown/json artifacts are optional only. The message branch must load the full generate-messages prompt, must read live campaign/review-batch state through scoped MCP/product tools, must reject mismatched selectedLeadListId/workflowTableId/campaign/workspace input, and may use the create-campaign-v2 message-review safety gate as a supplemental approval check. Join before message review.",
+            parentThreadRule: "Named agents are optional acceleration. If they are absent, do not customer-surface install status; the main thread still orchestrates filter and message branches from CampaignOffer state, selected source state, workflowTableId, and imported review-batch rows. Local markdown/json files are not normal-path inputs. The message branch must load the full generate-messages prompt, must read live campaign/review-batch state through scoped MCP/product tools, must reject mismatched selectedLeadListId/workflowTableId/campaign/workspace input, and may use the create-campaign-v2 message-review safety gate as a supplemental approval check. Join before message review. Do not automatically rerun Message Draft Builder after filters/enrichment finish; show the initial draft by default and offer an enriched rewrite only with explicit user opt-in.",
         },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/mcp",
-  "version": "0.1.136",
+  "version": "0.1.138",
   "type": "module",
   "description": "Sellable MCP server for Claude Code and Codex campaign workflows",
   "main": "dist/index.js",

package/skills/craft-message/SKILL.md

@@ -78,7 +78,7 @@ Parallel execution:
 
 Config tools (built-in, free):
 
-- `Read` - Load voice configs, outbound rules, and cross-skill insights from `.sellable/`
+- `Read` - Load core identity/company memory, proof/wins ledgers, anti-AI audit, outbound rules, and cross-skill insights from `.sellable/`
 
 Research tools (free - user's Claude tokens):
 
@@ -111,8 +111,14 @@ Parallel batch (6 calls):
 ├── get_rows(rowId)                                    → prospect data
 ├── get_message_prompt()                               → REPLY framework
 ├── get_subskill_prompt({ subskillName: "research-prospect" })  → research protocol
+├── Read .sellable/configs/core/about-me.md            → core identity memory
+├── Read .sellable/configs/core/my-company.md          → company truth
+├── Read .sellable/configs/core/context-modes.md       → outbound context mode
+├── Read .sellable/configs/core/proof-ledger.md        → safe proof claims
+├── Read .sellable/configs/core/wins-ledger.md         → social proof and wins
+├── Read .sellable/configs/core/anti-ai-writing-style.md → anti-AI audit
 ├── Read .sellable/configs/writing/outbound.md         → outbound rules
-├── Read .sellable/configs/writing/styleguide-core.md  → sender voice
+├── Read .sellable/configs/writing/styleguide-core.md  → legacy sender voice fallback
 └── Read .sellable/insights/cross-skill.md             → cross-skill learnings
 ```
 
@@ -161,6 +167,8 @@ Extract the following from the REPLY framework, configs, and research into a sin
 - Core thesis: {1 line from styleguide-core.md}
 - Signature phrases: {3-5 key phrases from styleguide-core.md}
 - Offer: {1 line from campaign brief}
+- Core memory: {1-2 lines from core/about-me.md, my-company.md, and context-modes.md}
+- Safe proof: {best usable proof from proof-ledger.md or campaign brief}
 
 ### Message Rules
 - Structure: observation about THEM → why it's relevant → soft ask
@@ -271,7 +279,7 @@ After all 10 angle agents return, **you (the Opus orchestrator) act as the final
    - Does the bridge prove the sender has a unique perspective? The message should make the prospect think "this person actually gets it" — not "this person read my LinkedIn headline."
    - Is there at least one sentence that would make the prospect stop scrolling? Something surprising, specific, or contrarian.
    - Kill any line that reads like a template. If you've seen it in a cold outreach before, rewrite it.
-5. **Voice-check** — does it sound like the sender? Use their signature phrases from `styleguide-core.md` (the FULL file, not the condensed brief).
+5. **Voice-check** — does it sound like the sender? Use core identity/context modes first, then legacy signature phrases from `styleguide-core.md` as fallback/source material.
 6. **Full 12-gate check using the REPLY framework** — this is the only place the full framework is applied. All gates must pass on the combined message. The angle agents drafted creatively; you enforce compliance.
 7. **Polish** — one final pass for flow, tone, and length
 
@@ -379,7 +387,7 @@ After saving (and optionally approving), return control for:
 
 ## Critical Rules
 
-1. **Load configs first** — read `.sellable/configs/writing/outbound.md` and `styleguide-core.md` before crafting. The message must sound like the sender.
+1. **Load core memory first** — read `.sellable/configs/core/about-me.md`, `my-company.md`, `context-modes.md`, `proof-ledger.md`, `wins-ledger.md`, and `anti-ai-writing-style.md` before crafting. Then read `.sellable/configs/writing/outbound.md` and legacy `styleguide-core.md` as fallback/source material. The message must sound like the sender and stay inside safe proof.
 2. **Load the framework first** — always call `get_message_prompt()` before crafting
 3. **Always fan out 10 angles** — never skip the angle exploration step. More angles = better final message. This is the core differentiator.
 4. **Launch agents in ONE message, no `run_in_background`** — all 10 angle agents (and all 6 research agents) must be launched as regular Task calls in a single message. They run concurrently and all results return together. Never use `run_in_background: true` — it causes notification spam.
@@ -392,6 +400,7 @@ After saving (and optionally approving), return control for:
 11. **Research deeply** — this is the value (5+ min per message). Compute time is the quality knob.
 12. Credits awareness — note when using LinkedIn tools
 13. **Use cross-skill insights** — if `insights/cross-skill.md` shows what hooks/angles resonate, use those patterns in the angle exploration
+14. **Anti-AI/proof final gate** — before showing a message, check `anti-ai-writing-style.md`, `proof-ledger.md`, `wins-ledger.md`, and `context-modes.md`; remove unsupported proof, stale wins, fake-depth reframes, and context-inappropriate voice.
 
 ## Developer Note