@sellable/mcp 0.1.137 → 0.1.139

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/mcp",
-  "version": "0.1.137",
+  "version": "0.1.139",
   "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
 

package/skills/create-campaign/references/brief-template.md

@@ -40,8 +40,9 @@ Example: "In a 15-minute call, we will audit your top 10 accounts and show where
 - **Lead with:** [Hook based on their posts/news]
 - **Bridge to:** [How it connects to their pain]
 - **Avoid:** [Generic phrases to skip - "best-in-class", "industry-leading", etc.]
-- **Voice:** [Reference sender's voice from `.sellable/configs/writing/styleguide-core.md` if loaded]
+- **Voice:** [Reference core memory / composed engage memory first. Use legacy writing memory only as fallback.]
 - **Outbound rules:** [Reference `.sellable/configs/writing/outbound.md` if loaded -- observation -> relevance -> ask]
+- **Proof boundaries:** [Reference `.sellable/configs/core/proof-ledger.md` and `.sellable/configs/core/wins-ledger.md` if loaded. Do not upgrade or invent claims.]
 
 ## Do NOT Target