@sellable/mcp 0.1.263 → 0.1.264

package/dist/server.js

@@ -9,7 +9,7 @@ import { getCampaignTableSchema, queueCampaignCells, reviseMessageTemplateAndRer
 import { createCampaign, duplicateCampaign, getCampaign, getCampaignMessagesPreview, getCampaigns, pauseCampaign, startCampaign, updateCampaign, updateCampaignBrief, } from "./tools/campaigns.js";
 import { queueCells, updateCell } from "./tools/cells.js";
 import { handleStartCliLogin, handleWaitForCliLogin, } from "./tools/cli-login.js";
-import { capturePostIdeaTool, getPostDraftTool, getPostIdeaTool, getPublishedPostTool, listPostDraftIterationsTool, listPostDraftsTool, listPostIdeasTool, listPublishedPostsTool, markPostPublishedTool, renderLinkedInPostPreviewTool, saveHookResearchTool, savePostDraftTool, updatePostDraftTool, updatePublishedPostMetricsTool, } from "./tools/content-posts.js";
+import { calculateLinkedInHookPreviewTool, capturePostIdeaTool, getPostDraftTool, getPostIdeaTool, getPublishedPostTool, listPostDraftIterationsTool, listPostDraftsTool, listPostIdeasTool, listPublishedPostsTool, markPostPublishedTool, renderLinkedInPostPreviewTool, saveHookResearchTool, savePostDraftTool, updatePostDraftTool, updatePublishedPostMetricsTool, } from "./tools/content-posts.js";
 import { getCampaignContext, hydrateCampaignContextFromCampaign, markCampaignContextDirty, } from "./tools/context.js";
 import { addToCommentCampaign, addToConnectionCampaign, addToInmailCampaign, getEngagedPosts, getOrCreateDirectCampaignTable, pauseDirectCampaign, startDirectCampaign, } from "./tools/direct-campaigns.js";
 import { bootstrapEngage, bootstrapEngageMulti, } from "./tools/engage-bootstrap.js";
@@ -244,6 +244,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "save_post_draft":
                 result = savePostDraftTool(args);
                 break;
+            case "calculate_linkedin_hook_preview":
+                result = calculateLinkedInHookPreviewTool(args);
+                break;
             case "render_linkedin_post_preview":
                 result = renderLinkedInPostPreviewTool(args);
                 break;

package/dist/tools/content-posts.d.ts

@@ -95,8 +95,15 @@ export declare const contentPostToolDefinitions: ({
             validationReceipt?: undefined;
             status?: undefined;
             postText?: undefined;
-            renderId?: undefined;
             sourceLabel?: undefined;
+            measurementMode?: undefined;
+            requireBrowserMeasurement?: undefined;
+            clampLines?: undefined;
+            mobileClampLines?: undefined;
+            desktopClampLines?: undefined;
+            mobileTextWidthPx?: undefined;
+            desktopTextWidthPx?: undefined;
+            renderId?: undefined;
             renderScreenshots?: undefined;
             requireScreenshots?: undefined;
             reviewClampLines?: undefined;
@@ -200,8 +207,15 @@ export declare const contentPostToolDefinitions: ({
             validationReceipt?: undefined;
             status?: undefined;
             postText?: undefined;
-            renderId?: undefined;
             sourceLabel?: undefined;
+            measurementMode?: undefined;
+            requireBrowserMeasurement?: undefined;
+            clampLines?: undefined;
+            mobileClampLines?: undefined;
+            desktopClampLines?: undefined;
+            mobileTextWidthPx?: undefined;
+            desktopTextWidthPx?: undefined;
+            renderId?: undefined;
             renderScreenshots?: undefined;
             requireScreenshots?: undefined;
             reviewClampLines?: undefined;
@@ -273,8 +287,15 @@ export declare const contentPostToolDefinitions: ({
             previewBudget?: undefined;
             notes?: undefined;
             postText?: undefined;
-            renderId?: undefined;
             sourceLabel?: undefined;
+            measurementMode?: undefined;
+            requireBrowserMeasurement?: undefined;
+            clampLines?: undefined;
+            mobileClampLines?: undefined;
+            desktopClampLines?: undefined;
+            mobileTextWidthPx?: undefined;
+            desktopTextWidthPx?: undefined;
+            renderId?: undefined;
             renderScreenshots?: undefined;
             requireScreenshots?: undefined;
             reviewClampLines?: undefined;
@@ -292,6 +313,91 @@ export declare const contentPostToolDefinitions: ({
         required: string[];
         additionalProperties: boolean;
     };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            postText: {
+                type: string;
+                description: string;
+            };
+            draftId: {
+                type: string;
+                description: string;
+            };
+            sourceLabel: {
+                type: string;
+            };
+            measurementMode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            requireBrowserMeasurement: {
+                type: string;
+                description: string;
+            };
+            clampLines: {
+                type: string;
+                description: string;
+            };
+            mobileClampLines: {
+                type: string;
+                description: string;
+            };
+            desktopClampLines: {
+                type: string;
+                description: string;
+            };
+            mobileTextWidthPx: {
+                type: string;
+                description: string;
+            };
+            desktopTextWidthPx: {
+                type: string;
+                description: string;
+            };
+            rawSource?: undefined;
+            title?: undefined;
+            distilledBrief?: undefined;
+            ideaId?: undefined;
+            sourceType?: undefined;
+            sourceUrl?: undefined;
+            capturedAt?: undefined;
+            researchId?: undefined;
+            topic?: undefined;
+            keywords?: undefined;
+            sourcePosts?: undefined;
+            selectedPatterns?: undefined;
+            previewBudget?: undefined;
+            notes?: undefined;
+            createdAt?: undefined;
+            hookResearchId?: undefined;
+            priorDraftId?: undefined;
+            iteration?: undefined;
+            body?: undefined;
+            validationReceipt?: undefined;
+            status?: undefined;
+            renderId?: undefined;
+            renderScreenshots?: undefined;
+            requireScreenshots?: undefined;
+            reviewClampLines?: undefined;
+            updatedAt?: undefined;
+            publishUrl?: undefined;
+            activityId?: undefined;
+            publishedAt?: undefined;
+            finalText?: undefined;
+            updateDraftStatus?: undefined;
+            publishedPostId?: undefined;
+            year?: undefined;
+            metrics?: undefined;
+            note?: undefined;
+        };
+        required: never[];
+        additionalProperties: boolean;
+    };
 } | {
     name: string;
     description: string;
@@ -348,6 +454,13 @@ export declare const contentPostToolDefinitions: ({
             body?: undefined;
             validationReceipt?: undefined;
             status?: undefined;
+            measurementMode?: undefined;
+            requireBrowserMeasurement?: undefined;
+            clampLines?: undefined;
+            mobileClampLines?: undefined;
+            desktopClampLines?: undefined;
+            mobileTextWidthPx?: undefined;
+            desktopTextWidthPx?: undefined;
             updatedAt?: undefined;
             publishUrl?: undefined;
             activityId?: undefined;
@@ -414,8 +527,15 @@ export declare const contentPostToolDefinitions: ({
             notes?: undefined;
             createdAt?: undefined;
             postText?: undefined;
-            renderId?: undefined;
             sourceLabel?: undefined;
+            measurementMode?: undefined;
+            requireBrowserMeasurement?: undefined;
+            clampLines?: undefined;
+            mobileClampLines?: undefined;
+            desktopClampLines?: undefined;
+            mobileTextWidthPx?: undefined;
+            desktopTextWidthPx?: undefined;
+            renderId?: undefined;
             renderScreenshots?: undefined;
             requireScreenshots?: undefined;
             reviewClampLines?: undefined;
@@ -482,8 +602,15 @@ export declare const contentPostToolDefinitions: ({
             validationReceipt?: undefined;
             status?: undefined;
             postText?: undefined;
-            renderId?: undefined;
             sourceLabel?: undefined;
+            measurementMode?: undefined;
+            requireBrowserMeasurement?: undefined;
+            clampLines?: undefined;
+            mobileClampLines?: undefined;
+            desktopClampLines?: undefined;
+            mobileTextWidthPx?: undefined;
+            desktopTextWidthPx?: undefined;
+            renderId?: undefined;
             renderScreenshots?: undefined;
             requireScreenshots?: undefined;
             reviewClampLines?: undefined;
@@ -540,8 +667,15 @@ export declare const contentPostToolDefinitions: ({
             validationReceipt?: undefined;
             status?: undefined;
             postText?: undefined;
-            renderId?: undefined;
             sourceLabel?: undefined;
+            measurementMode?: undefined;
+            requireBrowserMeasurement?: undefined;
+            clampLines?: undefined;
+            mobileClampLines?: undefined;
+            desktopClampLines?: undefined;
+            mobileTextWidthPx?: undefined;
+            desktopTextWidthPx?: undefined;
+            renderId?: undefined;
             renderScreenshots?: undefined;
             requireScreenshots?: undefined;
             reviewClampLines?: undefined;
@@ -639,6 +773,71 @@ export declare function savePostDraftTool(input: {
     updatedAt: string;
     preview: string;
 };
+type LinkedInHookPreviewSurface = {
+    label: "mobile" | "desktop";
+    textWidthPx: number;
+    fontSizePx: number;
+    lineHeightPx: number;
+    clampLines: number;
+    charGuardrail: number;
+    renderedLines: string[];
+    visibleLines: string[];
+    visibleTextBlock: string;
+    visibleTextBlockCharCount: number;
+    withinCharGuardrail: boolean;
+    lineCountBeforeClamp: number;
+    blankLinesBeforeClamp: number;
+    truncated: boolean;
+    seeMoreWouldShow: boolean;
+    hiddenTextStartsWith?: string;
+    measurementBasis: "local_chrome_browser_layout" | "estimated_width_model";
+    measurementWarning?: string;
+    chromePath?: string;
+};
+export declare function calculateLinkedInHookPreviewTool(input: {
+    postText?: string;
+    draftId?: string;
+    sourceLabel?: string;
+    measurementMode?: "browser" | "estimated";
+    requireBrowserMeasurement?: boolean;
+    clampLines?: number;
+    mobileClampLines?: number;
+    desktopClampLines?: number;
+    mobileTextWidthPx?: number;
+    desktopTextWidthPx?: number;
+}): {
+    basis: string;
+    ruleConfidence: string;
+    cssContractVersion: string;
+    sourceLabel: string | undefined;
+    draftId: string | undefined;
+    ruleSummary: string;
+    rules: {
+        visibleUnit: string;
+        defaultClampLines: number;
+        fontSizePx: number;
+        lineHeightPx: number;
+        whiteSpace: string;
+        overflowWrap: string;
+        desktopCharGuardrail: number;
+        mobileCharGuardrail: number;
+        characterCountsAreGuardrailsOnly: boolean;
+        notOfficialLinkedInApi: boolean;
+        strongestEvidence: string;
+    };
+    mobile: LinkedInHookPreviewSurface;
+    desktop: LinkedInHookPreviewSurface;
+    diagnostics: {
+        charCount: number;
+        charCountIncludingNewlines: number;
+        firstLineChars: number;
+        firstTwoPhysicalLinesChars: number;
+        physicalLineCount: number;
+        contentLineCount: number;
+        longestNonblankLineChars: number;
+        blankLineCount: number;
+    };
+};
 export declare function renderLinkedInPostPreviewTool(input: {
     postText?: string;
     draftId?: string;

package/dist/tools/content-posts.js

@@ -5,6 +5,24 @@ import { execFileSync } from "node:child_process";
 import { pathToFileURL } from "node:url";
 const CONTENT_ROOT_ENV = "SELLABLE_CONTENT_DIR";
 const DEFAULT_PREVIEW_CHARS = 220;
+const LINKEDIN_PREVIEW_CONTRACT_VERSION = "linkedin-preview-rendering/v2";
+const LINKEDIN_PREVIEW_FONT_SIZE_PX = 14;
+const LINKEDIN_PREVIEW_LINE_HEIGHT_PX = 21;
+const LINKEDIN_DEFAULT_CLAMP_LINES = 3;
+const LINKEDIN_MOBILE_CHAR_GUARDRAIL = 140;
+const LINKEDIN_DESKTOP_CHAR_GUARDRAIL = 210;
+const LINKEDIN_PREVIEW_SURFACES = {
+    mobile: {
+        textWidthPx: 308,
+        viewportWidthPx: 390,
+        viewportHeightPx: 760,
+    },
+    desktop: {
+        textWidthPx: 582,
+        viewportWidthPx: 744,
+        viewportHeightPx: 760,
+    },
+};
 const RELATIVE_DIRS = {
     ideas: "linkedin/ideas",
     hookResearch: "linkedin/research/hooks",
@@ -107,6 +125,55 @@ export const contentPostToolDefinitions = [
             additionalProperties: false,
         },
     },
+    {
+        name: "calculate_linkedin_hook_preview",
+        description: "Functionally calculate the LinkedIn pre-see-more hook for mobile and desktop. Returns rendered visible lines and rule diagnostics without writing files.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                postText: {
+                    type: "string",
+                    description: "Full post text or hook block to calculate. Provide either postText or draftId.",
+                },
+                draftId: {
+                    type: "string",
+                    description: "Optional saved draft ID. When postText is omitted, the tool calculates this draft's Draft Body.",
+                },
+                sourceLabel: { type: "string" },
+                measurementMode: {
+                    type: "string",
+                    enum: ["browser", "estimated"],
+                    description: "Defaults to browser. Browser mode uses local Chrome layout measurement when available; estimated mode uses the deterministic width model.",
+                },
+                requireBrowserMeasurement: {
+                    type: "boolean",
+                    description: "Defaults to false. When true, fail if local Chrome cannot measure rendered lines.",
+                },
+                clampLines: {
+                    type: "number",
+                    description: "Visible rendered lines before see-more for both surfaces. Defaults to 3.",
+                },
+                mobileClampLines: {
+                    type: "number",
+                    description: "Optional mobile-specific visible rendered line count. Defaults to clampLines.",
+                },
+                desktopClampLines: {
+                    type: "number",
+                    description: "Optional desktop-specific visible rendered line count. Defaults to clampLines.",
+                },
+                mobileTextWidthPx: {
+                    type: "number",
+                    description: "Optional mobile text width override. Defaults to 308px.",
+                },
+                desktopTextWidthPx: {
+                    type: "number",
+                    description: "Optional desktop text width override. Defaults to 582px.",
+                },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+    },
     {
         name: "render_linkedin_post_preview",
         description: "Render any LinkedIn post text through the Sellable LinkedIn preview CSS contract for mobile and desktop. Writes HTML artifacts and, when local Chrome is available, browser screenshots under ~/.sellable/content/linkedin/previews.",
@@ -429,16 +496,54 @@ export function savePostDraftTool(input) {
         preview: sanitizedPreview(input.body),
     };
 }
+export function calculateLinkedInHookPreviewTool(input) {
+    const { postText, draftId } = resolveLinkedInPreviewPostText(input);
+    const defaultClampLines = boundedWholeNumber(input.clampLines, LINKEDIN_DEFAULT_CLAMP_LINES, 1, 8);
+    const measurementMode = input.measurementMode ?? "browser";
+    const mobile = calculateLinkedInHookPreviewSurface({
+        label: "mobile",
+        text: postText,
+        textWidthPx: boundedWholeNumber(input.mobileTextWidthPx, LINKEDIN_PREVIEW_SURFACES.mobile.textWidthPx, 160, 900),
+        clampLines: boundedWholeNumber(input.mobileClampLines, defaultClampLines, 1, 8),
+        measurementMode,
+        requireBrowserMeasurement: input.requireBrowserMeasurement,
+    });
+    const desktop = calculateLinkedInHookPreviewSurface({
+        label: "desktop",
+        text: postText,
+        textWidthPx: boundedWholeNumber(input.desktopTextWidthPx, LINKEDIN_PREVIEW_SURFACES.desktop.textWidthPx, 260, 1200),
+        clampLines: boundedWholeNumber(input.desktopClampLines, defaultClampLines, 1, 8),
+        measurementMode,
+        requireBrowserMeasurement: input.requireBrowserMeasurement,
+    });
+    return {
+        basis: "linkedin_rendering_rule_function",
+        ruleConfidence: "calibrated_from_observed_linkedin_feed_screenshots_and_public_line_clamp_behavior",
+        cssContractVersion: LINKEDIN_PREVIEW_CONTRACT_VERSION,
+        sourceLabel: input.sourceLabel || draftId,
+        draftId,
+        ruleSummary: "The hook is the text visible before see more. The review gate is rendered line count, not a fixed character count. Blank lines consume visible lines.",
+        rules: {
+            visibleUnit: "rendered_visual_line",
+            defaultClampLines: LINKEDIN_DEFAULT_CLAMP_LINES,
+            fontSizePx: LINKEDIN_PREVIEW_FONT_SIZE_PX,
+            lineHeightPx: LINKEDIN_PREVIEW_LINE_HEIGHT_PX,
+            whiteSpace: "pre-wrap",
+            overflowWrap: "break-word",
+            desktopCharGuardrail: LINKEDIN_DESKTOP_CHAR_GUARDRAIL,
+            mobileCharGuardrail: LINKEDIN_MOBILE_CHAR_GUARDRAIL,
+            characterCountsAreGuardrailsOnly: true,
+            notOfficialLinkedInApi: true,
+            strongestEvidence: "authenticated LinkedIn feed screenshot on the target surface",
+        },
+        mobile,
+        desktop,
+        diagnostics: previewDiagnostics(postText),
+    };
+}
 export function renderLinkedInPostPreviewTool(input) {
     const now = normalizeDate(input.createdAt);
-    const draftId = input.draftId
-        ? normalizeArtifactId(input.draftId, "draftId")
-        : undefined;
-    const draftBody = draftId
-        ? extractMarkdownSection(getArtifact(RELATIVE_DIRS.drafts, draftId, "draftId").markdown, "Draft Body")
-        : undefined;
-    const postText = input.postText ?? draftBody;
-    requireString(postText, "postText");
+    const { postText, draftId } = resolveLinkedInPreviewPostText(input);
     const reviewClampLines = typeof input.reviewClampLines === "number" &&
         Number.isFinite(input.reviewClampLines)
         ? Math.max(1, Math.min(Math.floor(input.reviewClampLines), 8))
@@ -453,18 +558,18 @@ export function renderLinkedInPostPreviewTool(input) {
         label: "mobile",
         text: postText,
         baseDir,
-        textWidthPx: 308,
-        viewportWidthPx: 390,
-        viewportHeightPx: 760,
+        textWidthPx: LINKEDIN_PREVIEW_SURFACES.mobile.textWidthPx,
+        viewportWidthPx: LINKEDIN_PREVIEW_SURFACES.mobile.viewportWidthPx,
+        viewportHeightPx: LINKEDIN_PREVIEW_SURFACES.mobile.viewportHeightPx,
         reviewClampLines,
     });
     const desktop = buildPreviewSurface({
         label: "desktop",
         text: postText,
         baseDir,
-        textWidthPx: 582,
-        viewportWidthPx: 744,
-        viewportHeightPx: 760,
+        textWidthPx: LINKEDIN_PREVIEW_SURFACES.desktop.textWidthPx,
+        viewportWidthPx: LINKEDIN_PREVIEW_SURFACES.desktop.viewportWidthPx,
+        viewportHeightPx: LINKEDIN_PREVIEW_SURFACES.desktop.viewportHeightPx,
         reviewClampLines,
     });
     const combinedHtmlRelativePath = `${baseDir}/preview.html`;
@@ -491,7 +596,7 @@ export function renderLinkedInPostPreviewTool(input) {
         basis: screenshotResult.status === "rendered"
             ? "local_chrome_headless_screenshot"
             : "linkedin_css_contract_html",
-        cssContractVersion: "linkedin-preview-rendering/v1",
+        cssContractVersion: LINKEDIN_PREVIEW_CONTRACT_VERSION,
         generatedAt: now,
         sourceLabel: title,
         mobile: surfaceRecord(mobile),
@@ -760,6 +865,199 @@ export function listPublishedPostsTool(input) {
     }
     return summarizeArtifacts(artifacts, input?.limit);
 }
+function resolveLinkedInPreviewPostText(input) {
+    const draftId = input.draftId
+        ? normalizeArtifactId(input.draftId, "draftId")
+        : undefined;
+    const draftBody = draftId
+        ? extractMarkdownSection(getArtifact(RELATIVE_DIRS.drafts, draftId, "draftId").markdown, "Draft Body")
+        : undefined;
+    const postText = input.postText ?? draftBody;
+    requireString(postText, "postText");
+    return { postText, draftId };
+}
+function boundedWholeNumber(value, fallback, min, max) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    return Math.max(min, Math.min(Math.floor(value), max));
+}
+function calculateLinkedInHookPreviewSurface(input) {
+    const measurement = measureLinkedInRenderedLines({
+        text: input.text,
+        textWidthPx: input.textWidthPx,
+        measurementMode: input.measurementMode,
+        requireBrowserMeasurement: input.requireBrowserMeasurement,
+    });
+    const visibleLines = measurement.lines.slice(0, input.clampLines);
+    const hiddenLines = measurement.lines.slice(input.clampLines);
+    const visibleTextBlock = visibleLines.join("\n");
+    const charGuardrail = input.label === "mobile"
+        ? LINKEDIN_MOBILE_CHAR_GUARDRAIL
+        : LINKEDIN_DESKTOP_CHAR_GUARDRAIL;
+    return {
+        label: input.label,
+        textWidthPx: input.textWidthPx,
+        fontSizePx: LINKEDIN_PREVIEW_FONT_SIZE_PX,
+        lineHeightPx: LINKEDIN_PREVIEW_LINE_HEIGHT_PX,
+        clampLines: input.clampLines,
+        charGuardrail,
+        renderedLines: measurement.lines,
+        visibleLines,
+        visibleTextBlock,
+        visibleTextBlockCharCount: visibleTextBlock.length,
+        withinCharGuardrail: visibleTextBlock.length <= charGuardrail,
+        lineCountBeforeClamp: measurement.lines.length,
+        blankLinesBeforeClamp: visibleLines.filter((line) => line.trim().length === 0).length,
+        truncated: hiddenLines.length > 0,
+        seeMoreWouldShow: hiddenLines.length > 0,
+        hiddenTextStartsWith: hiddenLines.find((line) => line.trim().length > 0),
+        measurementBasis: measurement.basis,
+        measurementWarning: measurement.warning,
+        chromePath: measurement.chromePath,
+    };
+}
+function measureLinkedInRenderedLines(input) {
+    if (input.measurementMode === "browser") {
+        const browserMeasurement = measureLinkedInRenderedLinesWithChrome(input.text, input.textWidthPx);
+        if (browserMeasurement)
+            return browserMeasurement;
+        if (input.requireBrowserMeasurement) {
+            throw new Error("Chrome executable not found or browser line measurement failed. Set CHROME_PATH or use measurementMode=estimated.");
+        }
+    }
+    return {
+        lines: estimateRenderedLines(input.text, input.textWidthPx),
+        basis: "estimated_width_model",
+        warning: input.measurementMode === "browser"
+            ? "local Chrome measurement unavailable; used deterministic width estimate"
+            : undefined,
+    };
+}
+function measureLinkedInRenderedLinesWithChrome(text, textWidthPx) {
+    const chromePath = findChromeExecutable();
+    if (!chromePath)
+        return null;
+    const htmlPath = path.join(os.tmpdir(), `sellable-linkedin-hook-preview-${process.pid}-${Date.now()}-${Math.random()
+        .toString(36)
+        .slice(2)}.html`);
+    try {
+        fs.writeFileSync(htmlPath, buildLineMeasurementHtml(text, textWidthPx), "utf8");
+        const dom = execFileSync(chromePath, [
+            "--headless=new",
+            "--disable-gpu",
+            "--no-sandbox",
+            "--disable-dev-shm-usage",
+            "--hide-scrollbars",
+            "--dump-dom",
+            pathToFileURL(htmlPath).href,
+        ], { encoding: "utf8", timeout: 20000, stdio: ["ignore", "pipe", "ignore"] });
+        const encoded = dom.match(/data-linkedin-lines="([^"]+)"/)?.[1];
+        if (!encoded)
+            return null;
+        const decoded = Buffer.from(encoded, "base64").toString("utf8");
+        const parsed = JSON.parse(decoded);
+        if (!Array.isArray(parsed) ||
+            parsed.some((line) => typeof line !== "string")) {
+            return null;
+        }
+        return {
+            lines: parsed,
+            basis: "local_chrome_browser_layout",
+            chromePath,
+        };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        fs.rmSync(htmlPath, { force: true });
+    }
+}
+function buildLineMeasurementHtml(text, textWidthPx) {
+    return [
+        "<!doctype html>",
+        '<html lang="en">',
+        "<head>",
+        '<meta charset="utf-8">',
+        '<meta name="viewport" content="width=device-width, initial-scale=1">',
+        "</head>",
+        "<body>",
+        "<script>",
+        `const text = ${jsonForInlineScript(text)};`,
+        `const textWidthPx = ${textWidthPx};`,
+        `const fontSizePx = ${LINKEDIN_PREVIEW_FONT_SIZE_PX};`,
+        `const lineHeightPx = ${LINKEDIN_PREVIEW_LINE_HEIGHT_PX};`,
+        `
+const div = document.createElement("div");
+div.style.cssText = [
+  "position:absolute",
+  "left:0",
+  "top:0",
+  "width:" + textWidthPx + "px",
+  "font-family:-apple-system,system-ui,'Segoe UI',Roboto,'Helvetica Neue','Fira Sans',Ubuntu,'Oxygen Sans',Cantarell,'Droid Sans','Lucida Grande',Helvetica,Arial,sans-serif",
+  "font-size:" + fontSizePx + "px",
+  "line-height:" + lineHeightPx + "px",
+  "font-weight:400",
+  "letter-spacing:normal",
+  "white-space:pre-wrap",
+  "overflow-wrap:break-word",
+  "color:#000"
+].join(";");
+Array.from(text).forEach((char, index) => {
+  if (char === "\\n") {
+    div.appendChild(document.createTextNode("\\n"));
+    return;
+  }
+  const span = document.createElement("span");
+  span.dataset.index = String(index);
+  span.textContent = char;
+  div.appendChild(span);
+});
+document.body.appendChild(div);
+
+const lines = [];
+let currentText = null;
+let currentTop = null;
+let previousTop = null;
+function flushLine() {
+  if (currentText !== null) {
+    lines.push(currentText.trimEnd());
+    currentText = null;
+    currentTop = null;
+  }
+}
+
+for (const span of div.querySelectorAll("span")) {
+  const rect = span.getClientRects()[0];
+  if (!rect) continue;
+  const top = Math.round(rect.top * 10) / 10;
+  if (currentTop === null || Math.abs(top - currentTop) > 2) {
+    flushLine();
+    if (previousTop !== null) {
+      const blankCount = Math.max(0, Math.round((top - previousTop) / lineHeightPx) - 1);
+      for (let index = 0; index < blankCount; index += 1) lines.push("");
+    }
+    currentText = "";
+    currentTop = top;
+    previousTop = top;
+  }
+  currentText += span.textContent;
+}
+flushLine();
+document.documentElement.setAttribute(
+  "data-linkedin-lines",
+  btoa(unescape(encodeURIComponent(JSON.stringify(lines))))
+);
+`,
+        "</script>",
+        "</body>",
+        "</html>",
+        "",
+    ].join("\n");
+}
+function jsonForInlineScript(value) {
+    return JSON.stringify(value).replace(/</g, "\\u003c");
+}
 function buildPreviewSurface(input) {
     const estimatedLines = estimateRenderedLines(input.text, input.textWidthPx);
     const htmlPath = `${input.baseDir}/${input.label}.html`;
@@ -768,8 +1066,8 @@ function buildPreviewSurface(input) {
         textWidthPx: input.textWidthPx,
         viewportWidthPx: input.viewportWidthPx,
         viewportHeightPx: input.viewportHeightPx,
-        fontSizePx: 14,
-        lineHeightPx: 21,
+        fontSizePx: LINKEDIN_PREVIEW_FONT_SIZE_PX,
+        lineHeightPx: LINKEDIN_PREVIEW_LINE_HEIGHT_PX,
         reviewClampLines: input.reviewClampLines,
         estimatedLines,
         estimatedVisibleTextBlock: estimatedLines

package/dist/tools/registry.d.ts

@@ -1261,8 +1261,15 @@ export declare const allTools: ({
             validationReceipt?: undefined;
             status?: undefined;
             postText?: undefined;
-            renderId?: undefined;
             sourceLabel?: undefined;
+            measurementMode?: undefined;
+            requireBrowserMeasurement?: undefined;
+            clampLines?: undefined;
+            mobileClampLines?: undefined;
+            desktopClampLines?: undefined;
+            mobileTextWidthPx?: undefined;
+            desktopTextWidthPx?: undefined;
+            renderId?: undefined;
             renderScreenshots?: undefined;
             requireScreenshots?: undefined;
             reviewClampLines?: undefined;
@@ -1347,8 +1354,15 @@ export declare const allTools: ({
             previewBudget?: undefined;
             notes?: undefined;
             postText?: undefined;
-            renderId?: undefined;
             sourceLabel?: undefined;
+            measurementMode?: undefined;
+            requireBrowserMeasurement?: undefined;
+            clampLines?: undefined;
+            mobileClampLines?: undefined;
+            desktopClampLines?: undefined;
+            mobileTextWidthPx?: undefined;
+            desktopTextWidthPx?: undefined;
+            renderId?: undefined;
             renderScreenshots?: undefined;
             requireScreenshots?: undefined;
             reviewClampLines?: undefined;
@@ -1418,8 +1432,15 @@ export declare const allTools: ({
             notes?: undefined;
             createdAt?: undefined;
             postText?: undefined;
-            renderId?: undefined;
             sourceLabel?: undefined;
+            measurementMode?: undefined;
+            requireBrowserMeasurement?: undefined;
+            clampLines?: undefined;
+            mobileClampLines?: undefined;
+            desktopClampLines?: undefined;
+            mobileTextWidthPx?: undefined;
+            desktopTextWidthPx?: undefined;
+            renderId?: undefined;
             renderScreenshots?: undefined;
             requireScreenshots?: undefined;
             reviewClampLines?: undefined;
@@ -1486,8 +1507,15 @@ export declare const allTools: ({
             validationReceipt?: undefined;
             status?: undefined;
             postText?: undefined;
-            renderId?: undefined;
             sourceLabel?: undefined;
+            measurementMode?: undefined;
+            requireBrowserMeasurement?: undefined;
+            clampLines?: undefined;
+            mobileClampLines?: undefined;
+            desktopClampLines?: undefined;
+            mobileTextWidthPx?: undefined;
+            desktopTextWidthPx?: undefined;
+            renderId?: undefined;
             renderScreenshots?: undefined;
             requireScreenshots?: undefined;
             reviewClampLines?: undefined;
@@ -1544,8 +1572,15 @@ export declare const allTools: ({
             validationReceipt?: undefined;
             status?: undefined;
             postText?: undefined;
-            renderId?: undefined;
             sourceLabel?: undefined;
+            measurementMode?: undefined;
+            requireBrowserMeasurement?: undefined;
+            clampLines?: undefined;
+            mobileClampLines?: undefined;
+            desktopClampLines?: undefined;
+            mobileTextWidthPx?: undefined;
+            desktopTextWidthPx?: undefined;
+            renderId?: undefined;
             renderScreenshots?: undefined;
             requireScreenshots?: undefined;
             reviewClampLines?: undefined;

package/package.json

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

package/skills/create-post/SKILL.md

@@ -108,6 +108,7 @@ Use these MCP tools when available:
 - `mcp__sellable__get_post_idea`
 - `mcp__sellable__list_post_ideas`
 - `mcp__sellable__save_hook_research`
+- `mcp__sellable__calculate_linkedin_hook_preview`
 - `mcp__sellable__render_linkedin_post_preview`
 - `mcp__sellable__save_post_draft`
 - `mcp__sellable__update_post_draft`
@@ -343,8 +344,9 @@ Visible Flow Trace
 
 4. Hook Autopsies
 - source hook:
-- rendered/mobile preview artifact from `render_linkedin_post_preview` or
-  authenticated LinkedIn screenshot:
+- calculated mobile/desktop visible blocks from
+  `calculate_linkedin_hook_preview` or authenticated LinkedIn screenshot:
+- optional visual artifact from `render_linkedin_post_preview`:
 - see-more tension:
 - curiosity debt:
 - body promise:
@@ -404,7 +406,8 @@ Visible Flow Trace
 
 11. Hook Lab
 - at least 12 hooks:
-- rendered preview artifact from `render_linkedin_post_preview`:
+- calculated preview from `calculate_linkedin_hook_preview`:
+- optional visual artifact from `render_linkedin_post_preview` for finalists:
 - hook-to-body promise:
 - score:
 - selected hook:
@@ -838,10 +841,12 @@ media, and line break. Treat character counts as diagnostics only, not as proof
 that the hook will render before "see more."
 
 The selected hook and top candidates must include literal mobile and desktop
-visible blocks. Current third-party preview tools and 2026 creator references
-generally cluster around mobile showing about 2-3 text lines and desktop showing
-about 3-4 text lines before "see more," with media attachments sometimes showing
-less. Blank lines and `--` separators consume visible preview lines.
+visible blocks from `mcp__sellable__calculate_linkedin_hook_preview`.
+Observed LinkedIn screenshots and current third-party preview tools support a
+line-count model: review the first 3 rendered visual lines, not the first 210
+characters. Blank lines and `--` separators consume visible preview lines.
+Use `mcp__sellable__render_linkedin_post_preview` only when a visual QA artifact
+is useful.
 
 Use:
 

package/skills/create-post/references/linkedin-preview-rendering.md

@@ -5,45 +5,49 @@ research, hook candidate generation, gold-standard decomposition, and draft
 validation.
 
 Character budgets are only diagnostics. They are not the preview gate. A hook is
-not studied, selected, or ready until it has been rendered through
-`mcp__sellable__render_linkedin_post_preview` or through a stricter
+not studied, selected, or ready until its visible mobile and desktop blocks come
+from `mcp__sellable__calculate_linkedin_hook_preview` or from a stricter
 authenticated LinkedIn screenshot.
 
-Do not let the LLM imagine wrapping. Character counts and hand-written line
-blocks are only fallback diagnostics. The normal path is tool-rendered mobile
-and desktop artifacts: HTML always, and PNG screenshots whenever local Chrome is
-available.
+Do not let the LLM imagine wrapping. The normal path is a function call that
+returns rendered mobile and desktop lines. HTML and PNG outputs from
+`mcp__sellable__render_linkedin_post_preview` are optional visual QA artifacts,
+not the primary interface.
 
 ## Rendering Basis
 
 LinkedIn does not publish exact feed truncation rules, and rendering can vary by
 surface, app version, device, media attachment, and account state. Use this
-deterministic renderer as the MCP review gate for unpublished drafts.
+deterministic function as the MCP review gate for unpublished drafts.
+
+Simple operating policy: judge the hook by the first 3 rendered lines. Use ~140
+characters on mobile and ~210 characters on desktop as guardrails only. If the
+3-line preview and the character guardrail disagree, trust the rendered lines.
 
 Call:
 
 ```json
-mcp__sellable__render_linkedin_post_preview({
+mcp__sellable__calculate_linkedin_hook_preview({
   "postText": "<full post text or candidate hook block>",
   "sourceLabel": "<draft id, hook id, or source label>",
-  "renderScreenshots": true
+  "measurementMode": "browser"
 })
 ```
 
-When screenshots are produced, the PNG files are the review artifact. When
-screenshots cannot be produced, the HTML artifact is still deterministic and
-must be opened or explicitly marked as lower confidence.
+When local Chrome is available, browser measurement is the preferred functional
+basis because it asks the browser layout engine to wrap the text under the
+contract. When Chrome is unavailable, the tool falls back to the deterministic
+width model and must mark that basis.
 
 Treat "see more" as a rendered-line problem first and a character-count problem
-second. Current third-party preview tools and 2026 creator references generally
-cluster around these working assumptions:
-
-- mobile feed: about 2-3 visible text lines, often around 140 characters when
-  there is no media
-- desktop feed: about 3-4 visible text lines, often around 210 characters when
-  there is no media
-- posts with media may show fewer text lines before truncation, sometimes only
-  1-2 lines
+second. Observed LinkedIn screenshots show the current desktop feed behaving
+like a first-3-rendered-lines clamp: a first line, a blank line, and a third
+line can be all that appears before `... more`.
+
+- review gate: first 3 rendered visual lines
+- mobile feed: tighter because the text column is narrower
+- desktop feed: more characters can fit per line, but still review line count
+- posts with media may show fewer text lines before truncation
 - blank lines and intentional separators consume visible preview lines
 - device width, font scaling, app version, browser, and profile/page context can
   move the cutoff
@@ -86,13 +90,16 @@ selected hook must include a `renderedPreview` record:
 
 ```text
 renderedPreview:
-  basis: local_chrome_headless_screenshot | linkedin_css_contract_html | authenticated_linkedin_screenshot | manual_user_source
-  cssContractVersion: linkedin-preview-rendering/v1
+  basis: linkedin_rendering_rule_function | authenticated_linkedin_screenshot | manual_user_source
+  cssContractVersion: linkedin-preview-rendering/v2
   mobile:
     textWidthPx: 308
     fontSizePx: 14
     lineHeightPx: 21
-    visibleTextBlock: <literal first rendered review-clamp block or tool estimated block when screenshot is the authority>
+    clampLines: 3
+    charGuardrail: 140
+    measurementBasis: local_chrome_browser_layout | estimated_width_model
+    visibleTextBlock: <literal first 3 rendered lines>
     renderedLines:
       - <line 1 exactly as wrapped>
       - <line 2 exactly as wrapped>
@@ -106,13 +113,14 @@ renderedPreview:
     payoffPlannedImmediatelyAfterClamp: true | false
     seeMoreClickReason: <why a reader would click see more>
     seeMoreRisk: pass | warn | fail
-    htmlPath: <local path>
-    screenshotPath: <local path when Chrome rendered PNG>
   desktop:
     textWidthPx: 582
     fontSizePx: 14
     lineHeightPx: 21
-    visibleTextBlock: <literal first rendered review-clamp block>
+    clampLines: 3
+    charGuardrail: 210
+    measurementBasis: local_chrome_browser_layout | estimated_width_model
+    visibleTextBlock: <literal first 3 rendered lines>
     renderedLines:
       - <line 1 exactly as wrapped>
       - <line 2 exactly as wrapped>
@@ -122,8 +130,6 @@ renderedPreview:
     corePainProofOrCuriosityVisible: true | false
     corePointVisible: true | false
     seeMoreRisk: pass | warn | fail
-    htmlPath: <local path>
-    screenshotPath: <local path when Chrome rendered PNG>
   diagnostics:
     charCount: <number>
     charCountIncludingNewlines: <number>
@@ -136,11 +142,9 @@ renderedPreview:
     rewriteIfTruncated: <short fallback>
 ```
 
-If a host cannot produce screenshots, it must still produce and preserve the
-HTML artifacts from `render_linkedin_post_preview`. If it cannot produce
-screenshots, HTML artifacts, or literal wrapped line blocks, return `blocked` or
-`needs_revision`; do not claim the hook passed preview validation from character
-counts alone.
+If a host cannot produce literal wrapped line blocks from
+`calculate_linkedin_hook_preview`, return `blocked` or `needs_revision`; do not
+claim the hook passed preview validation from character counts alone.
 
 ## Study Rules