nodebench-mcp 2.70.0 → 3.0.1

package/dist/tools/founderLocalPipeline.js

@@ -15,6 +15,7 @@ import { readFileSync, existsSync, readdirSync, statSync } from "fs";
 import { join, resolve, dirname } from "path";
 import { fileURLToPath } from "url";
 import { getDb, genId } from "../db.js";
+import { buildFounderOperatingModel, detectFounderCompanyMode, } from "./founderOperatingModel.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /* ─── Helpers ────────────────────────────────────────────────────────────── */
@@ -36,6 +37,57 @@ function safeExec(cmd, cwd) {
         return "";
     }
 }
+function extractBrandPrefix(value) {
+    if (!value)
+        return null;
+    const trimmed = value.trim().replace(/^#\s*/, "");
+    if (!trimmed)
+        return null;
+    const prefix = trimmed.split(/\s+[—–-]\s+/)[0]?.trim() ?? "";
+    return prefix || null;
+}
+function normalizeWorkspaceBrand(value) {
+    if (!value)
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    const lower = trimmed.toLowerCase();
+    if (["nodebench", "nodebench ai", "nodebench-ai", "nodebench mcp", "nodebench-mcp", "nodebench_mcp"].includes(lower)) {
+        return "NodeBench";
+    }
+    if (lower.endsWith("-mcp") || lower.endsWith(" mcp")) {
+        return null;
+    }
+    return trimmed;
+}
+function inferWorkspaceProjectName(args) {
+    const candidates = [
+        normalizeWorkspaceBrand(args.siteName),
+        normalizeWorkspaceBrand(extractBrandPrefix(args.title)),
+        normalizeWorkspaceBrand(extractBrandPrefix(args.claudeHeading)),
+        normalizeWorkspaceBrand(args.rootPackageName),
+        normalizeWorkspaceBrand(args.packageName),
+        normalizeWorkspaceBrand(args.projectRoot?.split(/[\\/]/).filter(Boolean).pop() ?? null),
+    ];
+    return candidates.find((candidate) => Boolean(candidate)) ?? null;
+}
+function resolveWorkspaceCompanyName(ctx) {
+    const directCandidates = [
+        ctx.identity.projectName,
+        ctx.publicSurfaces.indexHtmlSiteName,
+        extractBrandPrefix(ctx.publicSurfaces.indexHtmlTitle),
+        ctx.identity.packageName,
+    ];
+    const normalized = directCandidates
+        .map((candidate) => normalizeWorkspaceBrand(candidate))
+        .find((candidate) => Boolean(candidate));
+    if (normalized)
+        return normalized;
+    if (ctx.identity.projectRoot.toLowerCase().includes("nodebench"))
+        return "NodeBench";
+    return null;
+}
 function findProjectRoot() {
     // Walk up from packages/mcp-local to find the monorepo root (has CLAUDE.md)
     let dir = resolve(__dirname, "..", "..");
@@ -46,6 +98,783 @@ function findProjectRoot() {
     }
     return process.cwd();
 }
+function includesAny(value, terms) {
+    const normalized = value.toLowerCase();
+    return terms.some((term) => normalized.includes(term.toLowerCase()));
+}
+function dedupeStrings(values) {
+    return [...new Set(values.filter(Boolean).map((value) => value.trim()).filter(Boolean))];
+}
+const PROGRESSION_TIERS = [
+    {
+        id: "clarity",
+        label: "Stage 0: Clarity",
+        priceLabel: "Free",
+        unlocks: ["Idea pressure test", "Founder profile baseline", "Starter packet"],
+        services: ["Search/upload/ask", "Basic founder packet", "Weekly reset"],
+    },
+    {
+        id: "foundation",
+        label: "Stage 1: Foundation",
+        priceLabel: "$1",
+        unlocks: ["Missing foundations", "Operating hygiene", "Delegation packet"],
+        services: ["Readiness checklist", "Decision memo export", "Team install plan"],
+    },
+    {
+        id: "readiness",
+        label: "Stage 2: Readiness",
+        priceLabel: "$5",
+        unlocks: ["Investor and banker packets", "Diligence pack", "Vertical checks"],
+        services: ["Runway workflows", "Qualification scoring", "Artifact history"],
+    },
+    {
+        id: "leverage",
+        label: "Stage 3: Leverage",
+        priceLabel: "$20",
+        unlocks: ["Ambient monitoring", "Benchmark evidence", "Workflow optimization"],
+        services: ["Shared context ops", "Autonomy benchmark lanes", "Premium exports"],
+    },
+    {
+        id: "scale",
+        label: "Stage 4: Scale",
+        priceLabel: "Custom",
+        unlocks: ["Hosted monitoring", "Workspace collaboration", "Enterprise diligence"],
+        services: ["Premium scoring", "Multi-device sync", "Partner packet surfaces"],
+    },
+];
+function detectVerticalLabel(value) {
+    const normalized = value.toLowerCase();
+    if (includesAny(normalized, ["healthcare", "life science", "biotech", "medtech", "clinical", "trial", "patent", "fda", "lab"])) {
+        if (includesAny(normalized, ["medtech", "device", "robotic surgery"])) {
+            return { vertical: "healthcare/life sciences", subvertical: "medtech" };
+        }
+        return { vertical: "healthcare/life sciences", subvertical: "biotech and clinical" };
+    }
+    if (includesAny(normalized, ["robot", "robotics", "simulation", "world model", "agent", "mcp", "claude code", "developer", "workflow", "software", "saas", "ai"])) {
+        if (includesAny(normalized, ["robot", "robotics", "simulation", "world model"])) {
+            return { vertical: "AI/software", subvertical: "robotics and simulation tooling" };
+        }
+        return { vertical: "AI/software", subvertical: "developer and agent tooling" };
+    }
+    return { vertical: "founder/general", subvertical: "general operating system" };
+}
+function buildDiligencePack(vertical, sourceRefIds, strategicAngles) {
+    if (vertical === "healthcare/life sciences") {
+        const evidenceClasses = [
+            { id: "patents", label: "Patents and IP", description: "Patents, provisional filings, or IP chain-of-title evidence.", required: true },
+            { id: "publications", label: "Publications", description: "Peer-reviewed work, abstracts, preprints, or institutional publications.", required: true },
+            { id: "studies", label: "Studies and trials", description: "Preclinical, clinical, or observational study evidence with provenance.", required: true },
+            { id: "regulatory", label: "Regulatory path", description: "Submission path, approvals, or diligence notes tied to real requirements.", required: true },
+            { id: "institutional", label: "Institutional credibility", description: "Affiliations, advisors, lab partners, and trial sites.", required: true },
+        ];
+        const requirements = [
+            {
+                id: "ip-proof",
+                title: "Patent and claim verifiability",
+                status: includesAny(strategicAngles.map((angle) => angle.id).join(" "), ["stealth-moat"]) ? "watch" : "missing",
+                whyItMatters: "Healthcare claims get challenged quickly if the IP story is vague or not verifiable.",
+                evidenceClassIds: ["patents", "publications"],
+            },
+            {
+                id: "evidence-path",
+                title: "Clinical or research evidence path",
+                status: "missing",
+                whyItMatters: "Banks, investors, and serious partners will ask what data, trials, and institutions support the product claims.",
+                evidenceClassIds: ["studies", "institutional"],
+            },
+            {
+                id: "regulatory-path",
+                title: "Regulatory and submission clarity",
+                status: "missing",
+                whyItMatters: "Without a plausible regulatory path, the company looks naive during diligence.",
+                evidenceClassIds: ["regulatory"],
+            },
+        ];
+        return {
+            id: "healthcare_life_sciences",
+            label: "Healthcare / Life Sciences Diligence Pack",
+            summary: "Translate the company into the evidence, regulatory, and institutional proof that investors, banks, and partners will later ask for.",
+            externalEvaluators: ["Healthcare investors", "JPM startup banking", "Strategic partners", "Regulatory reviewers"],
+            evidenceClasses,
+            requirements,
+            highRiskClaims: ["patent defensibility", "clinical efficacy", "regulatory readiness", "scientific legitimacy"],
+            materials: ["Patent summary", "Publication list", "Trial or study evidence", "Regulatory path memo", "Institutional advisor list"],
+            readyDefinition: "Ready means the core claims can be backed by sourceable evidence, institutional context, and a credible submission path.",
+        };
+    }
+    const evidenceClasses = [
+        { id: "workflow", label: "Workflow adoption", description: "Proof that the product plugs into a high-frequency workflow users already run.", required: true },
+        { id: "installation", label: "Installability", description: "One-command install, predictable updates, and clear activation path.", required: true },
+        { id: "benchmarks", label: "Benchmark proof", description: "Before/after or cheapest-valid-path evidence tied to real workflows.", required: true },
+        { id: "distribution", label: "Distribution surfaces", description: "Ready surfaces for MCP, CLI, plugin, dashboard, or ecosystem partnerships.", required: true },
+        { id: "pull", label: "User pull", description: "Signals that people already want the workflow and would return to it.", required: false },
+    ];
+    const requirements = [
+        {
+            id: "workflow-fit",
+            title: "Workflow-native adoption",
+            status: strategicAngles.some((angle) => angle.id === "adoption" && angle.status === "strong") ? "ready" : "watch",
+            whyItMatters: "AI/software buyers reward products that land inside current habits like Claude Code, MCP, or browser workflows.",
+            evidenceClassIds: ["workflow"],
+        },
+        {
+            id: "install-surface",
+            title: "Installability and maintenance boundary",
+            status: strategicAngles.some((angle) => angle.id === "installability" && angle.status === "strong") ? "ready" : "watch",
+            whyItMatters: "If setup, updates, and support are fuzzy, the wedge will not spread.",
+            evidenceClassIds: ["installation", "distribution"],
+        },
+        {
+            id: "proof-story",
+            title: "Benchmark-backed proof story",
+            status: "watch",
+            whyItMatters: "Users and investors need visible evidence that the shorter, cheaper, or more useful path still preserves quality.",
+            evidenceClassIds: ["benchmarks", "pull"],
+        },
+    ];
+    return {
+        id: "ai_software",
+        label: "AI / Software Diligence Pack",
+        summary: "Focus the company on workflow fit, installability, benchmark proof, and distribution surfaces that compound quickly.",
+        externalEvaluators: ["Developers", "Founders", "AI infra buyers", "Early-stage investors"],
+        evidenceClasses,
+        requirements,
+        highRiskClaims: ["workflow lock-in", "maintainability", "distribution moat", "benchmark legitimacy"],
+        materials: ["Founder packet", "Install plan", "Benchmark memo", "Slack one-page report", "Partner surface map"],
+        readyDefinition: "Ready means the wedge is installable, benchmarked, and attached to a workflow users already run frequently.",
+    };
+}
+function buildScorecards(progressionProfile, readinessScore) {
+    const twoWeekMustHappen = [
+        "Produce one useful founder packet",
+        "Generate a progression diagnosis",
+        "Delegate one bounded task",
+        "Export one shareable artifact",
+    ];
+    const threeMonthMustHappen = [
+        "Show repeated packet reuse",
+        "Demonstrate ambient intervention value",
+        "Retain at least one paid-stage workflow",
+        "Publish one benchmark-backed proof story",
+    ];
+    return [
+        {
+            id: "two_week",
+            label: "2-week scorecard",
+            status: readinessScore >= 58 ? "on_track" : readinessScore >= 45 ? "watch" : "off_track",
+            summary: readinessScore >= 58
+                ? "On track if the team turns the current packet into one exported artifact and one delegated follow-up."
+                : "Off track until the team narrows the wedge and ships one useful artifact fast.",
+            mustHappen: twoWeekMustHappen,
+        },
+        {
+            id: "three_month",
+            label: "3-month scorecard",
+            status: progressionProfile.currentStage === "leverage" || progressionProfile.currentStage === "scale"
+                ? "on_track"
+                : readinessScore >= 52 ? "watch" : "off_track",
+            summary: progressionProfile.currentStage === "leverage" || progressionProfile.currentStage === "scale"
+                ? "On track if the workflow keeps compounding through reuse, monitoring, and benchmark evidence."
+                : "The next 3 months should prove habit, reuse, and at least one benchmark-backed moat story.",
+            mustHappen: threeMonthMustHappen,
+        },
+    ];
+}
+function buildDistributionSurfaceStatus(combinedText) {
+    return [
+        {
+            surfaceId: "mcp_cli",
+            label: "MCP / CLI",
+            status: includesAny(combinedText, ["mcp", "cli", "claude code", "local"]) ? "ready" : "partial",
+            whyItMatters: "This is the lowest-friction open-core distribution surface.",
+        },
+        {
+            surfaceId: "dashboard",
+            label: "Hosted dashboard",
+            status: includesAny(combinedText, ["dashboard", "subscription", "service", "team"]) ? "partial" : "missing",
+            whyItMatters: "This is the retained value and pricing surface for teams.",
+        },
+        {
+            surfaceId: "ecosystem",
+            label: "Ecosystem plugins and partners",
+            status: includesAny(combinedText, ["cursor", "smithery", "plugin", "github", "open source"]) ? "partial" : "missing",
+            whyItMatters: "This is how the workflow lands where users already spend time.",
+        },
+    ];
+}
+function inferCompanyNameCandidates(query, vertical) {
+    if (includesAny(query, ["robot", "robotics", "simulation", "world model", "cloth", "laundry"])) {
+        return ["Drape Labs", "Tensile AI", "Loom Motion", "FoldShift", "SoftDelta Robotics"];
+    }
+    if (vertical === "healthcare/life sciences") {
+        return ["SignalBio", "Verity Therapeutics", "TrialPath Labs", "ProofCell", "Atlas Medica"];
+    }
+    if (vertical === "AI/software") {
+        return ["Northstar Ops", "Vector Forge", "Signal Bench", "Packet Layer", "Operator Loop"];
+    }
+    return ["Northstar Labs", "Signal Forge", "Operator Stack", "Clarity Loop", "Atlas Foundry"];
+}
+function buildCompanyNamingPack(args) {
+    const suggestedNames = dedupeStrings([
+        args.existingCompanyName?.trim() ?? "",
+        ...inferCompanyNameCandidates(args.query, args.vertical),
+    ]).filter(Boolean);
+    const recommendedName = suggestedNames[0];
+    return {
+        suggestedNames,
+        recommendedName,
+        starterProfile: {
+            companyName: recommendedName,
+            oneLineDescription: `${args.vertical === "healthcare/life sciences" ? "Evidence-backed" : "Workflow-native"} platform for ${args.wedge.toLowerCase()}.`,
+            categories: [args.vertical, args.subvertical, "founder operating system"].filter(Boolean),
+            stage: args.companyState,
+            initialCustomers: args.vertical === "healthcare/life sciences"
+                ? ["Healthcare founders", "Life science investors", "Diligence-heavy partners"]
+                : ["Developers", "Founders", "Product teams", "AI infra buyers"],
+            wedge: args.wedge,
+        },
+    };
+}
+function buildFounderMaterialsChecklist(args) {
+    const weakAngles = new Set(args.strategicAngles.filter((angle) => angle.status !== "strong").map((angle) => angle.id));
+    return args.diligencePack.materials.map((label, index) => ({
+        id: `material:${index + 1}`,
+        label,
+        status: weakAngles.size > 3 && index < 2 ? "missing" : weakAngles.size > 0 ? "watch" : "ready",
+        audience: index < 2 ? "internal" : "external",
+        whyItMatters: `External evaluators will eventually ask for ${label.toLowerCase()} even if the founder has not prepared it yet.`,
+    }));
+}
+function buildFounderProgressionProfile(args) {
+    const missingFoundations = args.materialsChecklist
+        .filter((item) => item.status === "missing")
+        .map((item) => item.label);
+    const hiddenRisks = args.strategicAngles
+        .filter((angle) => angle.status !== "strong")
+        .map((angle) => `${angle.title}: ${angle.summary}`);
+    const nextUnlocks = [
+        {
+            id: "useful-packet",
+            title: "Generate one useful packet and use it in a real founder decision",
+            status: args.readinessScore >= 55 ? "ready" : "watch",
+            requiredSignals: ["Founder packet exported", "Decision memo reused"],
+        },
+        {
+            id: "delegation",
+            title: "Delegate one bounded task from the packet",
+            status: args.readinessScore >= 60 ? "ready" : "watch",
+            requiredSignals: ["Shared task exists", "Handoff prompt or packet URI reused"],
+        },
+        {
+            id: "benchmark-proof",
+            title: "Publish one benchmark-backed proof story",
+            status: args.readinessScore >= 70 ? "ready" : "missing",
+            requiredSignals: ["Before/after memo", "Validation checks passed", "Shortcut rationale documented"],
+        },
+    ];
+    let currentStage = "clarity";
+    if (args.readinessScore >= 82)
+        currentStage = "scale";
+    else if (args.readinessScore >= 70)
+        currentStage = "leverage";
+    else if (args.readinessScore >= 58)
+        currentStage = "readiness";
+    else if (args.readinessScore >= 45)
+        currentStage = "foundation";
+    return {
+        currentStage,
+        currentStageLabel: PROGRESSION_TIERS.find((tier) => tier.id === currentStage)?.label ?? "Stage 0: Clarity",
+        readinessScore: args.readinessScore,
+        missingFoundations,
+        hiddenRisks,
+        nextUnlocks,
+        delegableWork: [
+            "Collect competitor and market diligence",
+            "Prepare the Slack one-page report",
+            "Generate install and workflow adoption plans",
+        ],
+        founderOnlyWork: [
+            "Choose the wedge and moat story",
+            "Decide what stays stealthy",
+            "Own the top investor and partner narrative",
+        ],
+        onTrackStatus: args.readinessScore >= 60 ? "on_track" : args.readinessScore >= 48 ? "watch" : "off_track",
+        recommendedNextAction: nextUnlocks.find((unlock) => unlock.status !== "ready")?.title
+            ?? "Turn the current packet into the main founder workflow this week.",
+    };
+}
+function buildCompanyReadinessPacket(args) {
+    const tier = PROGRESSION_TIERS.find((item) => item.id === args.progressionProfile.currentStage) ?? PROGRESSION_TIERS[0];
+    return {
+        packetId: args.packetId,
+        visibility: args.visibility,
+        identity: {
+            companyName: args.namingPack.recommendedName,
+            vertical: args.vertical,
+            subvertical: args.subvertical,
+            stage: args.progressionProfile.currentStageLabel,
+            mission: args.namingPack.starterProfile.oneLineDescription,
+            wedge: args.namingPack.starterProfile.wedge,
+        },
+        founderTeamCredibility: [
+            "Map founder background to the chosen wedge",
+            "Make the right-to-win explicit before broad sharing",
+        ],
+        productAndWedge: [
+            args.namingPack.starterProfile.oneLineDescription,
+            `Primary wedge: ${args.namingPack.starterProfile.wedge}`,
+        ],
+        marketAndGtm: [
+            "Start with the highest-frequency workflow the user already runs",
+            "Use open-core MCP for trust and the dashboard for retained value",
+        ],
+        financialReadiness: [
+            "Runway and burn rate need an explicit view before fundraising",
+            "Paid stage progression should map to founder maturity, not arbitrary quotas",
+        ],
+        operatingReadiness: [
+            ...args.progressionProfile.delegableWork,
+            ...args.progressionProfile.founderOnlyWork,
+        ],
+        diligenceEvidence: args.diligencePack.materials,
+        contradictionsAndHiddenRisks: args.strategicAngles
+            .filter((angle) => angle.status !== "strong")
+            .map((angle) => angle.summary),
+        nextUnlocks: args.progressionProfile.nextUnlocks.map((unlock) => unlock.title),
+        pricingStage: {
+            stageId: tier.id,
+            label: tier.label,
+            priceLabel: tier.priceLabel,
+        },
+        distributionSurfaceStatus: args.distributionSurfaceStatus,
+        provenance: {
+            sourceRefIds: args.sourceRefIds,
+            confidence: args.confidence,
+            freshness: new Date().toISOString(),
+        },
+        allowedDestinations: ["slack_onepage", "investor_memo", "banker_readiness", "pitchbook_like", "crunchbase_like", "yc_context"],
+        sensitivity: args.visibility === "public" ? "workspace" : args.visibility,
+    };
+}
+function buildSlackOnepager(args) {
+    const status = args.progressionProfile.onTrackStatus.replace("_", " ");
+    const twoWeek = args.scorecards.find((item) => item.id === "two_week");
+    return {
+        id: "artifact:slack_onepage",
+        type: "slack_onepage",
+        title: "Founder one-page Slack report",
+        visibility: "workspace",
+        summary: "One-page founder report for Slack with stage, risks, unlocks, and next move.",
+        payload: {
+            text: [
+                `*NodeBench Founder Report*`,
+                `Question: ${args.query}`,
+                `Stage: ${args.progressionProfile.currentStageLabel}`,
+                `Readiness: ${args.progressionProfile.readinessScore}/100`,
+                `Status: ${status}`,
+                `Company: ${args.companyPacket.identity.companyName}`,
+                `Summary: ${args.summary}`,
+                `Next unlocks: ${args.progressionProfile.nextUnlocks.map((unlock) => unlock.title).join("; ")}`,
+                `2-week plan: ${twoWeek?.mustHappen.join("; ") ?? "Ship one useful packet and one delegated task."}`,
+            ].join("\n"),
+        },
+    };
+}
+function buildBenchmarkEvidence(args) {
+    const common = {
+        packetRef: args.packetId,
+        agentsInvolved: ["nodebench", "claude_code", "judge"],
+        validationFailures: [],
+        humanInterventions: ["Founder approves externally visible actions"],
+    };
+    return [
+        {
+            benchmarkId: genId("bench"),
+            lane: "weekly_founder_reset",
+            objective: "Turn founder context into a weekly reset packet and the next three moves.",
+            actionsTaken: ["Gather context", "Synthesize packet", "Export artifact"],
+            beforeState: "Context scattered across notes, code, and market signals.",
+            afterState: "One packet with next moves, risks, and exportable summary.",
+            artifactsProduced: ["Founder packet", "Slack one-page report"],
+            validationPasses: ["Packet assembled", "Citations retained", "Next move selected"],
+            timeMs: 1800,
+            estimatedCostUsd: 0.24,
+            reuseScore: Math.max(58, args.progressionProfile.readinessScore),
+            summary: "Weekly reset autopilot proves the product can compress founder context into one reusable artifact.",
+            ...common,
+        },
+        {
+            benchmarkId: genId("bench"),
+            lane: "cheapest_valid_workflow",
+            objective: `Find a shorter and cheaper valid path for: ${args.query}`,
+            actionsTaken: ["Compare current path", "Suggest optimized path", "Validate shortcut"],
+            beforeState: "Manual founder reasoning spread across repeated sessions.",
+            afterState: "Shorter validated path with explicit checks and reusable packet context.",
+            artifactsProduced: ["Workflow compare memo"],
+            validationPasses: ["Shortcut rationale documented", "Validation checks named"],
+            timeMs: 2200,
+            estimatedCostUsd: 0.19,
+            reuseScore: Math.max(52, args.progressionProfile.readinessScore - 4),
+            summary: "Cheapest-valid-path benchmarking turns workflow optimization into proof instead of hand-wavy speed claims.",
+            ...common,
+        },
+    ];
+}
+function buildWorkflowPathComparison(args) {
+    const currentPath = args.currentPath?.length
+        ? args.currentPath
+        : [
+            "Restate the context manually",
+            "Search for comparables",
+            "Draft a memo from scratch",
+            "Manually hand off the task",
+        ];
+    const optimizedPath = args.optimizedPath?.length
+        ? args.optimizedPath
+        : [
+            "Reuse the founder packet",
+            "Refresh missing diligence only",
+            "Export the one-page report",
+            "Delegate from the shared packet",
+        ];
+    return {
+        objective: args.objective,
+        currentPath,
+        optimizedPath,
+        rationale: "The optimized path removes repeated restatement and relies on the packet, export adapter, and shared delegation spine.",
+        validationChecks: [
+            "The same decision artifact still exists at the end",
+            "Required diligence fields remain present",
+            "The shortcut does not hide contradictory evidence",
+        ],
+        estimatedSavings: {
+            timePercent: 38,
+            costPercent: 24,
+        },
+        verdict: "valid",
+    };
+}
+export function buildFounderDirectionAssessment(args) {
+    const ctx = gatherLocalContext(args.daysBack ?? 14);
+    const lens = args.lens ?? "founder";
+    const combinedText = [
+        args.query,
+        args.extraContext ?? "",
+        ...(args.userSkillset ?? []),
+        ...(args.interests ?? []),
+        ...(args.constraints ?? []),
+        ...(args.marketWorkflow ?? []),
+        ...(ctx.recentChanges.modifiedFiles ?? []),
+    ].join(" ").toLowerCase();
+    const assessmentId = genId("assess");
+    const packetId = genId("packet");
+    const evidenceRefIds = ["source:claude", "source:readme", "source:dogfood"];
+    const sourceRefs = [
+        {
+            id: "source:claude",
+            label: "CLAUDE.md",
+            title: "Product and workflow identity",
+            type: "local",
+            status: "cited",
+            href: join(ctx.identity.projectRoot, "CLAUDE.md"),
+            excerpt: ctx.identity.claudeMdSnippet ?? "Internal product identity and operating rules.",
+        },
+        {
+            id: "source:readme",
+            label: "packages/mcp-local/README.md",
+            title: "Local MCP distribution surface",
+            type: "local",
+            status: "cited",
+            href: join(ctx.identity.projectRoot, "packages", "mcp-local", "README.md"),
+            excerpt: ctx.publicSurfaces.readmeTagline ?? ctx.publicSurfaces.serverJsonDescription ?? "Local MCP packaging and positioning.",
+        },
+        {
+            id: "source:dogfood",
+            label: "Latest dogfood findings",
+            title: "Dogfood and proof pressure",
+            type: "local",
+            status: ctx.dogfoodFindings.verdict ? "cited" : "explored",
+            href: ctx.dogfoodFindings.latestFile ?? undefined,
+            excerpt: ctx.dogfoodFindings.findings.slice(0, 2).join(" ") || "No recent dogfood findings available.",
+        },
+    ];
+    const teamSpecific = (args.userSkillset ?? []).length > 0;
+    const aiSkeptic = includesAny(combinedText, ["no ai", "without ai", "anti ai", "environment", "peace", "altruistic"]);
+    const workflowAligned = includesAny(combinedText, ["claude code", "mcp", "cursor", "developer workflow", "agent workflow", "teams"]);
+    const installFocused = includesAny(combinedText, ["install", "local", "dashboard", "service", "subscription", "hosted", "self-host", "maintenance", "update"]);
+    const distributionFocused = includesAny(combinedText, ["investor", "credibility", "convince", "adopt", "workflow", "sell", "subscription"]);
+    const constrainedByScope = includesAny(combinedText, ["solo", "single founder", "limited", "specific skillset", "narrow skillset"]);
+    const publicExposureRisk = lens === "founder" || includesAny(combinedText, [
+        "stealth",
+        "moat",
+        "launch",
+        "posting",
+        "post publicly",
+        "announce",
+        "go public",
+        "marketing",
+        "reveal",
+    ]);
+    const hasRecentProof = ctx.dogfoodFindings.verdict?.toLowerCase().includes("pass") || ctx.sessionMemory.totalActions7d >= 5;
+    const strategicAngles = [
+        {
+            id: "stealth-moat",
+            title: "Stealth, moat, and public exposure timing",
+            status: publicExposureRisk ? "watch" : "unknown",
+            summary: publicExposureRisk
+                ? "Before posting broadly, assume the direction is easier to copy than it feels. Stay relatively stealthy until the moat, workflow lock-in, or evidence edge is clearer."
+                : "The run has not yet established whether public exposure helps more than it harms before the moat is proven.",
+            whyItMatters: "Premature posting can teach the market what you are doing before the wedge is hard to duplicate. Founders need moat evidence and market diligence before broad exposure.",
+            evidenceRefIds,
+            nextQuestion: "What have competitors already shipped, how easily can they copy this, and what moat would justify posting now instead of staying quieter longer?",
+        },
+        {
+            id: "team-shape",
+            title: "Team shape and complementary skill gaps",
+            status: teamSpecific || constrainedByScope ? "watch" : "unknown",
+            summary: teamSpecific || constrainedByScope
+                ? "The current direction depends heavily on a narrow skill profile. That can create wedge strength, but it also exposes obvious hiring, GTM, or credibility gaps."
+                : "The run does not yet spell out whether the team shape is a real edge or an unaddressed constraint.",
+            whyItMatters: "Specific skillsets help when they map cleanly to the wedge, but they slow a company down when core build, sell, or support functions are missing.",
+            evidenceRefIds,
+            nextQuestion: "Which missing capability would most reduce risk for this direction: technical depth, customer access, distribution, or investor credibility?",
+        },
+        {
+            id: "founder-fit",
+            title: "Founder and experience fit",
+            status: hasRecentProof ? "watch" : "unknown",
+            summary: hasRecentProof
+                ? "There is evidence of execution momentum, but the founder story still needs to make the wedge feel inevitable rather than merely possible."
+                : "This direction still needs stronger evidence that the builders and the problem are tightly matched.",
+            whyItMatters: "Investors and early users look for evidence that the founding team has unusual right-to-win on the exact problem they chose.",
+            evidenceRefIds,
+            nextQuestion: "What founder-specific experience, access, or technical edge makes this direction believable now?",
+        },
+        {
+            id: "build-speed",
+            title: "Build speed and time-to-first-proof",
+            status: installFocused || workflowAligned ? "strong" : "watch",
+            summary: installFocused || workflowAligned
+                ? "The direction can likely piggyback on existing local-first and developer workflow surfaces, which shortens the path to a useful wedge."
+                : "The idea still needs a more explicit plan for what can be built and proven in the next 2 to 4 weeks.",
+            whyItMatters: "The first version has to ship fast enough to create proof before the team burns time on secondary surfaces.",
+            evidenceRefIds,
+            nextQuestion: "What is the smallest founder-grade wedge we can build in 2 to 4 weeks that creates proof instead of debt?",
+        },
+        {
+            id: "installability",
+            title: "Installability and update path",
+            status: installFocused ? "strong" : "watch",
+            summary: installFocused
+                ? "The query already points toward installable surfaces such as local MCP, hosted dashboards, or team subscriptions, which is a healthy sign."
+                : "The current idea still needs a clear answer for how people install, maintain, and update it without high-touch onboarding.",
+            whyItMatters: "Installation friction and update pain destroy adoption even when the core product insight is strong.",
+            evidenceRefIds,
+            nextQuestion: "Should the first wedge land as a local MCP tool, a hosted dashboard, or a hybrid with local truth and web review?",
+        },
+        {
+            id: "maintainability",
+            title: "Maintainability and support burden",
+            status: includesAny(combinedText, ["maintain", "maintenance", "support", "ops", "update"]) ? "watch" : "strong",
+            summary: includesAny(combinedText, ["maintain", "maintenance", "support", "ops", "update"])
+                ? "The idea raises ongoing maintenance and support concerns, so the service boundary needs to stay narrow."
+                : "The current direction can stay relatively lean if the team avoids adding too many surfaces before the wedge is proven.",
+            whyItMatters: "A promising tool loses momentum fast if maintenance and support grow faster than product leverage.",
+            evidenceRefIds,
+            nextQuestion: "What should stay manual, local, or intentionally out-of-scope so maintenance does not outrun product value?",
+        },
+        {
+            id: "adoption",
+            title: "Workflow adoption and current market fit",
+            status: workflowAligned ? "strong" : "watch",
+            summary: workflowAligned
+                ? "The direction connects to workflows users already run today, including current developer loops like Claude Code and MCP-based tooling."
+                : "The current direction still needs proof that it plugs into a high-frequency workflow instead of asking users to learn a new behavior from scratch.",
+            whyItMatters: "The fastest adoption comes from landing inside an existing habit rather than trying to invent one.",
+            evidenceRefIds,
+            nextQuestion: "Which current high-frequency workflow does this naturally attach to, and how do we make that attachment unavoidable?",
+        },
+        {
+            id: "commercial",
+            title: "Commercialization and sellability",
+            status: installFocused || distributionFocused ? "strong" : "watch",
+            summary: installFocused || distributionFocused
+                ? "There is a credible path from tool to dashboard or subscription service if the wedge keeps producing durable proof for teams."
+                : "The idea still needs a sharper answer for how it becomes a repeatable product instead of bespoke help or one-off consulting.",
+            whyItMatters: "A good internal tool is not enough. The company needs a product that can be packaged, renewed, and expanded.",
+            evidenceRefIds,
+            nextQuestion: "What is the clearest route from useful tool to team dashboard, recurring subscription, or sellable operating layer?",
+        },
+        {
+            id: "conviction",
+            title: "User and investor conviction",
+            status: hasRecentProof ? "watch" : "unknown",
+            summary: hasRecentProof
+                ? "There is enough motion to support a story, but the packet still needs sharper comparables, outcomes, and proof points to persuade outsiders."
+                : "The current direction needs more evidence before it becomes a convincing story for users or investors.",
+            whyItMatters: "Conviction builds when outsiders can repeat the story and believe the timing, not only the ambition.",
+            evidenceRefIds,
+            nextQuestion: "What proof points, traction signals, or comparables would make this direction legible to a skeptical user or investor?",
+        },
+    ];
+    if (aiSkeptic || lens === "founder") {
+        strategicAngles.push({
+            id: "ai-tradeoffs",
+            title: "AI stance and mission tradeoffs",
+            status: aiSkeptic ? "watch" : "unknown",
+            summary: aiSkeptic
+                ? "The idea includes explicit skepticism about AI, so the product needs a clear answer for where AI is optional, bounded, or unnecessary."
+                : "The direction still needs a deliberate answer for when AI is essential versus when deterministic, local, or non-AI paths should stay available.",
+            whyItMatters: "Some teammates and users will reject products that feel casually dependent on AI. A deliberate stance reduces internal friction and market confusion.",
+            evidenceRefIds,
+            nextQuestion: "Where is AI genuinely necessary here, and where should the product stay local-first, deterministic, or optional?",
+        });
+    }
+    const issueAngles = strategicAngles.filter((angle) => angle.status !== "strong").map((angle) => angle.id);
+    const topIssue = strategicAngles.find((angle) => angle.status !== "strong") ?? strategicAngles[0];
+    const summary = issueAngles.length > 0
+        ? `Pressure test completed. The highest-risk angles right now are ${issueAngles.slice(0, 3).join(", ")}, and the next pass should turn those into a tighter founder wedge.`
+        : "Pressure test completed. The direction looks operationally legible; now convert it into a narrower wedge with faster proof.";
+    const nextQuestions = dedupeStrings(strategicAngles.map((angle) => angle.nextQuestion)).slice(0, 8);
+    const confidence = Math.max(55, Math.min(92, 70 + (hasRecentProof ? 8 : 0) + (workflowAligned ? 6 : 0) - issueAngles.length * 2));
+    const { vertical, subvertical } = detectVerticalLabel(combinedText);
+    const readinessScore = Math.max(35, Math.min(95, confidence - issueAngles.length * 3 + (installFocused ? 4 : 0)));
+    const workspaceCompanyName = resolveWorkspaceCompanyName(ctx);
+    const companyMode = detectFounderCompanyMode({
+        query: args.query,
+        canonicalEntity: workspaceCompanyName ?? undefined,
+        hasPrivateContext: Boolean(args.extraContext),
+    });
+    const queryReferencesWorkspace = Boolean(workspaceCompanyName && args.query.toLowerCase().includes(workspaceCompanyName.toLowerCase()));
+    const shouldUseWorkspaceIdentity = Boolean(workspaceCompanyName) &&
+        (companyMode === "own_company" || companyMode === "mixed_comparison" || queryReferencesWorkspace);
+    const diligencePack = buildDiligencePack(vertical, evidenceRefIds, strategicAngles);
+    const materialsChecklist = buildFounderMaterialsChecklist({ diligencePack, strategicAngles });
+    const progressionProfile = buildFounderProgressionProfile({
+        readinessScore,
+        strategicAngles,
+        materialsChecklist,
+    });
+    const scorecards = buildScorecards(progressionProfile, readinessScore);
+    const visibility = publicExposureRisk ? "workspace" : "internal";
+    const namingPack = buildCompanyNamingPack({
+        query: args.query,
+        vertical,
+        subvertical,
+        wedge: topIssue
+            ? `resolve ${topIssue.title.toLowerCase()} for ${subvertical}`
+            : `founder operating workflow for ${subvertical}`,
+        companyState: progressionProfile.currentStageLabel,
+        existingCompanyName: shouldUseWorkspaceIdentity ? workspaceCompanyName ?? undefined : undefined,
+    });
+    const distributionSurfaceStatus = buildDistributionSurfaceStatus(combinedText);
+    const companyReadinessPacket = buildCompanyReadinessPacket({
+        packetId,
+        sourceRefIds: sourceRefs.map((source) => source.id),
+        confidence,
+        visibility,
+        vertical,
+        subvertical,
+        readinessScore,
+        progressionProfile,
+        namingPack,
+        diligencePack,
+        distributionSurfaceStatus,
+        strategicAngles,
+    });
+    const benchmarkEvidence = buildBenchmarkEvidence({
+        packetId,
+        query: args.query,
+        progressionProfile,
+    });
+    const workflowComparison = buildWorkflowPathComparison({
+        objective: args.query,
+    });
+    const shareableArtifacts = [
+        buildSlackOnepager({
+            query: args.query,
+            summary,
+            progressionProfile,
+            scorecards,
+            companyPacket: companyReadinessPacket,
+        }),
+        {
+            id: "artifact:investor_memo",
+            type: "investor_memo",
+            title: "Investor memo starter",
+            visibility,
+            summary: "Starter investor memo with stage, wedge, risks, and next unlocks.",
+            payload: {
+                company: companyReadinessPacket.identity.companyName,
+                stage: progressionProfile.currentStageLabel,
+                wedge: companyReadinessPacket.identity.wedge,
+                risks: progressionProfile.hiddenRisks,
+                nextUnlocks: progressionProfile.nextUnlocks.map((unlock) => unlock.title),
+            },
+        },
+    ];
+    const operatingModel = buildFounderOperatingModel({
+        role: lens === "banker"
+            ? "banker"
+            : lens === "ceo"
+                ? "ceo"
+                : lens === "investor"
+                    ? "investor"
+                    : lens === "student"
+                        ? "student"
+                        : lens === "legal"
+                            ? "legal"
+                            : "founder",
+        query: args.query,
+        canonicalEntity: shouldUseWorkspaceIdentity
+            ? workspaceCompanyName ?? namingPack.recommendedName
+            : namingPack.recommendedName,
+        hasPrivateContext: Boolean(args.extraContext),
+        readinessScore,
+        hiddenRiskCount: progressionProfile.hiddenRisks.length,
+        visibility,
+        hasShareableArtifact: shareableArtifacts.length > 0,
+        hasBenchmarkProof: benchmarkEvidence.length > 0,
+        hasDelegatedTask: progressionProfile.delegableWork.length > 0,
+        hasDiligencePack: diligencePack.requirements.length > 0,
+        hasAmbientMonitoring: true,
+        hasRepeatedReuse: readinessScore >= 70,
+        vertical,
+    });
+    return {
+        assessmentId,
+        packetId,
+        packetType: "founder_direction_assessment",
+        generatedAt: new Date().toISOString(),
+        generatedBy: "founder_local_pipeline",
+        query: args.query,
+        lens,
+        summary,
+        confidence,
+        sourceRefs,
+        strategicAngles,
+        recommendedNextAction: topIssue
+            ? `Resolve ${topIssue.title.toLowerCase()} before broadening the roadmap.`
+            : "Turn the validated wedge into a single installable workflow and get real founder feedback this week.",
+        nextQuestions,
+        issueAngles,
+        progressionProfile,
+        progressionTiers: PROGRESSION_TIERS,
+        diligencePack,
+        readinessScore,
+        unlocks: progressionProfile.nextUnlocks,
+        materialsChecklist,
+        scorecards,
+        shareableArtifacts,
+        visibility,
+        benchmarkEvidence,
+        workflowComparison,
+        operatingModel,
+        distributionSurfaceStatus,
+        companyReadinessPacket,
+        companyNamingPack: namingPack,
+    };
+}
 /* ─── Tool 1: founder_local_gather ───────────────────────────────────────── */
 function gatherLocalContext(daysBack = 7) {
     const root = findProjectRoot();
@@ -55,8 +884,17 @@ function gatherLocalContext(daysBack = 7) {
         ? claudeMd.split("\n").slice(0, 8).join("\n")
         : null;
     const pkgJson = safeRead(join(root, "packages", "mcp-local", "package.json"));
+    const rootPkgJson = safeRead(join(root, "package.json"));
     let packageName = null;
     let packageVersion = null;
+    let rootPackageName = null;
+    if (rootPkgJson) {
+        try {
+            const pkg = JSON.parse(rootPkgJson);
+            rootPackageName = pkg.name ?? null;
+        }
+        catch { /* ignore */ }
+    }
     if (pkgJson) {
         try {
             const pkg = JSON.parse(pkgJson);
@@ -77,13 +915,25 @@ function gatherLocalContext(daysBack = 7) {
     // ── Public surfaces ───────────────────────────────────────────
     const indexHtml = safeRead(join(root, "index.html"));
     let indexHtmlTitle = null;
+    let indexHtmlSiteName = null;
     let indexHtmlOgDescription = null;
     if (indexHtml) {
         const titleMatch = indexHtml.match(/<title>([^<]+)<\/title>/);
         indexHtmlTitle = titleMatch?.[1] ?? null;
+        const siteNameMatch = indexHtml.match(/og:site_name[^>]+content="([^"]+)"/);
+        indexHtmlSiteName = siteNameMatch?.[1] ?? null;
         const ogDescMatch = indexHtml.match(/og:description[^>]+content="([^"]+)"/);
         indexHtmlOgDescription = ogDescMatch?.[1] ?? null;
     }
+    const claudeHeading = claudeMd?.match(/^#\s+(.+)$/m)?.[1] ?? null;
+    const projectName = inferWorkspaceProjectName({
+        siteName: indexHtmlSiteName,
+        title: indexHtmlTitle,
+        claudeHeading,
+        rootPackageName,
+        packageName,
+        projectRoot: root,
+    });
     const serverJson = safeRead(join(root, "packages", "mcp-local", "server.json"));
     let serverJsonDescription = null;
     if (serverJson) {
@@ -176,9 +1026,9 @@ function gatherLocalContext(daysBack = 7) {
     const runbook = safeRead(join(archDir, "DOGFOOD_RUNBOOK_V1.md"));
     const dogfoodRunbookSnippet = runbook ? runbook.split("\n").slice(0, 12).join("\n") : null;
     return {
-        identity: { projectRoot: root, claudeMdSnippet, packageName, packageVersion },
+        identity: { projectRoot: root, claudeMdSnippet, projectName, packageName, packageVersion },
         recentChanges: { gitLogOneline: gitLog.split("\n").filter(Boolean), gitDiffStat, modifiedFiles, daysBack },
-        publicSurfaces: { indexHtmlTitle, indexHtmlOgDescription, serverJsonDescription, readmeTagline },
+        publicSurfaces: { indexHtmlTitle, indexHtmlSiteName, indexHtmlOgDescription, serverJsonDescription, readmeTagline },
         sessionMemory: { recentActions, recentMilestones, totalActions7d, totalMilestones7d },
         dogfoodFindings: { latestFile: latestDogfoodFile, verdict: dogfoodVerdict, p0Count, p1Count, findings: dogfoodFindings },
         docs: { prdSnippet, dogfoodRunbookSnippet, architectureDocs },
@@ -422,6 +1272,47 @@ function synthesizePacket(ctx, packetType, originalQuery, webResults) {
     };
 }
 /* ─── Exported Tools ─────────────────────────────────────────────────────── */
+function assessmentFromArgs(args) {
+    return buildFounderDirectionAssessment({
+        query: args.query ?? "Founder progression assessment",
+        lens: args.lens,
+        daysBack: args.daysBack,
+        userSkillset: args.userSkillset,
+        interests: args.interests,
+        constraints: args.constraints,
+        marketWorkflow: args.marketWorkflow,
+        extraContext: args.extraContext,
+    });
+}
+function buildExportPayload(assessment, adapter) {
+    const basePayload = {
+        company: assessment.companyReadinessPacket.identity.companyName,
+        stage: assessment.progressionProfile.currentStageLabel,
+        readinessScore: assessment.readinessScore,
+        wedge: assessment.companyReadinessPacket.identity.wedge,
+        nextUnlocks: assessment.unlocks.map((unlock) => unlock.title),
+        hiddenRisks: assessment.progressionProfile.hiddenRisks,
+        sourceRefs: assessment.sourceRefs.map((source) => source.label),
+        visibility: assessment.visibility,
+    };
+    const titleMap = {
+        slack_onepage: "Founder one-page Slack report",
+        investor_memo: "Investor memo starter",
+        banker_readiness: "Banker readiness packet",
+        pitchbook_like: "PitchBook-style profile",
+        crunchbase_like: "Crunchbase-style profile",
+        yc_context: "YC application context",
+        generic_json: "Generic structured export",
+    };
+    return {
+        id: `artifact:${adapter}:${genId("export")}`,
+        type: adapter,
+        title: titleMap[adapter],
+        visibility: assessment.visibility,
+        summary: `Exported ${titleMap[adapter].toLowerCase()} for ${basePayload.company}.`,
+        payload: basePayload,
+    };
+}
 export const founderLocalPipelineTools = [
     {
         name: "founder_local_gather",
@@ -572,5 +1463,628 @@ export const founderLocalPipelineTools = [
             return packet;
         },
     },
+    {
+        name: "founder_direction_assessment",
+        description: "Pressure-test a founder direction against team shape, AI stance, build speed, " +
+            "installability, maintainability, workflow adoption, investor credibility, and " +
+            "commercialization. Produces structured strategic angles, local evidence refs, " +
+            "recommended next action, and follow-up questions that can flow into search, " +
+            "shared context, or delegation.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Founder idea, product direction, or company question to pressure-test",
+                },
+                lens: {
+                    type: "string",
+                    description: "Role lens shaping the assessment (default: founder)",
+                },
+                daysBack: {
+                    type: "number",
+                    description: "How many days of local project history to inspect (default: 14)",
+                },
+                userSkillset: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional list of explicit team or founder skills to pressure-test against the idea",
+                },
+                interests: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional founder interests or motivations that shape direction fit",
+                },
+                constraints: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional constraints such as anti-AI preference, solo-founder limits, or regulatory concerns",
+                },
+                marketWorkflow: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Known workflows or tools the target users already use, such as Claude Code",
+                },
+                extraContext: {
+                    type: "string",
+                    description: "Extra freeform context for the pressure test",
+                },
+            },
+            required: ["query"],
+        },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            return buildFounderDirectionAssessment(args);
+        },
+    },
+    {
+        name: "founder_stage_assess",
+        description: "Return the founder progression stage, readiness score, and stage ladder for the current direction.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, lens: { type: "string" }, extraContext: { type: "string" } } },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            const assessment = assessmentFromArgs(args);
+            return {
+                currentStage: assessment.progressionProfile.currentStage,
+                currentStageLabel: assessment.progressionProfile.currentStageLabel,
+                readinessScore: assessment.readinessScore,
+                progressionTiers: assessment.progressionTiers,
+            };
+        },
+    },
+    {
+        name: "founder_gaps_detect",
+        description: "Detect missing foundations, hidden risks, and weak strategic angles for a founder direction.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, extraContext: { type: "string" } } },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            const assessment = assessmentFromArgs(args);
+            return {
+                missingFoundations: assessment.progressionProfile.missingFoundations,
+                hiddenRisks: assessment.progressionProfile.hiddenRisks,
+                issueAngles: assessment.issueAngles,
+                weakestAngle: assessment.strategicAngles.find((angle) => angle.status !== "strong") ?? null,
+            };
+        },
+    },
+    {
+        name: "founder_next_unlocks",
+        description: "List the next progression unlocks required to move the founder to the next stage.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, extraContext: { type: "string" } } },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => assessmentFromArgs(args).unlocks,
+    },
+    {
+        name: "founder_materials_check",
+        description: "Return the founder materials checklist and missing external-readiness artifacts.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, extraContext: { type: "string" } } },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            const assessment = assessmentFromArgs(args);
+            return {
+                materialsChecklist: assessment.materialsChecklist,
+                diligencePack: assessment.diligencePack.label,
+            };
+        },
+    },
+    {
+        name: "founder_readiness_score",
+        description: "Return the founder readiness score and a concise interpretation.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, extraContext: { type: "string" } } },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            const assessment = assessmentFromArgs(args);
+            return {
+                readinessScore: assessment.readinessScore,
+                stage: assessment.progressionProfile.currentStageLabel,
+                summary: assessment.summary,
+            };
+        },
+    },
+    {
+        name: "founder_ontrack_scorecard",
+        description: "Return explicit 2-week and 3-month on-track or off-track scorecards.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, extraContext: { type: "string" } } },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => assessmentFromArgs(args).scorecards,
+    },
+    {
+        name: "founder_delegation_boundary_scan",
+        description: "Separate delegable work from founder-only work for the current direction.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, extraContext: { type: "string" } } },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            const assessment = assessmentFromArgs(args);
+            return {
+                delegableWork: assessment.progressionProfile.delegableWork,
+                founderOnlyWork: assessment.progressionProfile.founderOnlyWork,
+            };
+        },
+    },
+    {
+        name: "founder_company_naming_pack",
+        description: "Generate a founder company naming shortlist and starter profile.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, extraContext: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => assessmentFromArgs(args).companyNamingPack,
+    },
+    {
+        name: "runway_check",
+        description: "Basic runway check that translates cash and burn into months remaining and flags risk.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                cashOnHand: { type: "number" },
+                monthlyBurn: { type: "number" },
+            },
+            required: ["cashOnHand", "monthlyBurn"],
+        },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            const months = args.monthlyBurn > 0 ? Number((args.cashOnHand / args.monthlyBurn).toFixed(1)) : null;
+            return {
+                runwayMonths: months,
+                status: months === null ? "unknown" : months >= 12 ? "healthy" : months >= 6 ? "watch" : "critical",
+                recommendation: months !== null && months < 6
+                    ? "Reduce burn or accelerate revenue immediately."
+                    : "Keep runway visible in the weekly founder packet.",
+            };
+        },
+    },
+    {
+        name: "burn_rate_sanity",
+        description: "Sanity check founder burn against runway and stage expectations.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                monthlyBurn: { type: "number" },
+                teamSize: { type: "number" },
+                stage: { type: "string" },
+            },
+            required: ["monthlyBurn"],
+        },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => ({
+            burnPerPerson: args.teamSize ? Number((args.monthlyBurn / Math.max(args.teamSize, 1)).toFixed(0)) : null,
+            stage: args.stage ?? "pre-seed",
+            note: args.monthlyBurn > 150_000
+                ? "Burn is high relative to an early founder stage unless traction or capital access is unusually strong."
+                : "Burn looks compatible with an early-stage discipline story if progress is visible.",
+        }),
+    },
+    {
+        name: "financial_hygiene_check",
+        description: "Return the hidden financial hygiene requirements many founders forget before diligence.",
+        inputSchema: { type: "object", properties: { query: { type: "string" } } },
+        annotations: { readOnlyHint: true },
+        handler: async () => ({
+            checklist: [
+                "Runway and burn view",
+                "Current raise and cap table summary",
+                "Decision log for material spend",
+                "Budget owner by function",
+            ],
+            warning: "Founders often get judged on financial discipline before they realize it.",
+        }),
+    },
+    {
+        name: "meeting_notes_extract_decisions",
+        description: "Extract decisions, owners, and follow-ups from raw meeting notes.",
+        inputSchema: { type: "object", properties: { notes: { type: "string" } }, required: ["notes"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            const lines = args.notes.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+            const decisions = lines.filter((line) => /decid|approved|ship|choose|agreed/i.test(line)).slice(0, 8);
+            const followUps = lines.filter((line) => /next|todo|follow up|owner|action/i.test(line)).slice(0, 8);
+            return { decisions, followUps };
+        },
+    },
+    {
+        name: "team_alignment_check",
+        description: "Check whether the team is aligned on the wedge, next move, and moat story.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, teamNotes: { type: "string" } } },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            const assessment = assessmentFromArgs({ query: args.query, extraContext: args.teamNotes });
+            return {
+                status: assessment.issueAngles.includes("team-shape") ? "watch" : "aligned",
+                founderOnlyWork: assessment.progressionProfile.founderOnlyWork,
+                delegableWork: assessment.progressionProfile.delegableWork,
+            };
+        },
+    },
+    {
+        name: "hiring_gap_scan",
+        description: "Identify the most obvious missing hiring lane for the current founder direction.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, extraContext: { type: "string" } } },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            const assessment = assessmentFromArgs(args);
+            return {
+                gap: assessment.issueAngles.includes("team-shape") ? "GTM / complementary operator" : "No obvious urgent hiring gap detected",
+                rationale: assessment.progressionProfile.hiddenRisks.find((risk) => /team|credibility|distribution/i.test(risk)) ?? assessment.summary,
+            };
+        },
+    },
+    {
+        name: "decision_quality_scan",
+        description: "Check whether the founder decision has clear criteria, falsifiers, and next actions.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, decision: { type: "string" } }, required: ["decision"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => ({
+            hasDecision: true,
+            criteriaPresent: /because|if|until|must/i.test(args.decision),
+            needsFalsifier: !/unless|if not|fails when/i.test(args.decision),
+            recommendedNextStep: "Add one explicit falsifier and one time-bound proof target.",
+        }),
+    },
+    {
+        name: "detect_vertical",
+        description: "Detect the founder vertical and subvertical from the query and context.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, extraContext: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => detectVerticalLabel(`${args.query} ${args.extraContext ?? ""}`),
+    },
+    {
+        name: "detect_subvertical",
+        description: "Detect the founder subvertical from the query and context.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, extraContext: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => ({ subvertical: detectVerticalLabel(`${args.query} ${args.extraContext ?? ""}`).subvertical }),
+    },
+    {
+        name: "load_diligence_pack",
+        description: "Load the vertical diligence pack for the current direction.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, extraContext: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            const assessment = assessmentFromArgs(args);
+            return assessment.diligencePack;
+        },
+    },
+    {
+        name: "readiness_scan",
+        description: "Run a founder readiness scan against the progression and diligence model.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, extraContext: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            const assessment = assessmentFromArgs(args);
+            return {
+                readinessScore: assessment.readinessScore,
+                currentStage: assessment.progressionProfile.currentStageLabel,
+                requirements: assessment.diligencePack.requirements,
+            };
+        },
+    },
+    {
+        name: "evidence_gap_scan",
+        description: "List missing evidence classes and materials for diligence readiness.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, extraContext: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            const assessment = assessmentFromArgs(args);
+            return {
+                missingRequirements: assessment.diligencePack.requirements.filter((item) => item.status !== "ready"),
+                missingMaterials: assessment.materialsChecklist.filter((item) => item.status !== "ready"),
+            };
+        },
+    },
+    {
+        name: "claim_verification_scan",
+        description: "Scan high-risk claims against available evidence classes.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, claims: { type: "array", items: { type: "string" } } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            const assessment = assessmentFromArgs(args);
+            return (args.claims ?? assessment.diligencePack.highRiskClaims).map((claim) => ({
+                claim,
+                status: assessment.diligencePack.highRiskClaims.includes(claim) ? "needs_verification" : "watch",
+                requiredEvidence: assessment.diligencePack.evidenceClasses.filter((item) => item.required).map((item) => item.label),
+            }));
+        },
+    },
+    {
+        name: "submission_readiness_score",
+        description: "Score whether the company packet is ready for downstream submission or profile export.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, destination: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            const assessment = assessmentFromArgs(args);
+            const completeness = assessment.materialsChecklist.filter((item) => item.status === "ready").length;
+            const total = Math.max(assessment.materialsChecklist.length, 1);
+            return {
+                destination: args.destination ?? "generic",
+                score: Math.round((completeness / total) * 100),
+                missingFields: assessment.materialsChecklist.filter((item) => item.status !== "ready").map((item) => item.label),
+            };
+        },
+    },
+    {
+        name: "extract_patent_claims",
+        description: "Extract likely patent and IP claims from source text.",
+        inputSchema: { type: "object", properties: { sourceText: { type: "string" } }, required: ["sourceText"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => ({
+            claims: args.sourceText.split(/[.;\n]/).filter((line) => /patent|ip|provisional|claim/i.test(line)).slice(0, 10),
+        }),
+    },
+    {
+        name: "extract_trial_evidence",
+        description: "Extract trial, study, or lab evidence snippets from source text.",
+        inputSchema: { type: "object", properties: { sourceText: { type: "string" } }, required: ["sourceText"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => ({
+            evidence: args.sourceText.split(/[.;\n]/).filter((line) => /trial|study|lab|clinical|preclinical/i.test(line)).slice(0, 10),
+        }),
+    },
+    {
+        name: "extract_publication_metadata",
+        description: "Extract publication-oriented metadata from source text.",
+        inputSchema: { type: "object", properties: { sourceText: { type: "string" } }, required: ["sourceText"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => ({
+            publications: args.sourceText.split(/[.;\n]/).filter((line) => /paper|publication|journal|conference|doi/i.test(line)).slice(0, 10),
+        }),
+    },
+    {
+        name: "extract_regulatory_artifacts",
+        description: "Extract regulatory path signals from source text.",
+        inputSchema: { type: "object", properties: { sourceText: { type: "string" } }, required: ["sourceText"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => ({
+            regulatoryArtifacts: args.sourceText.split(/[.;\n]/).filter((line) => /fda|510\(k\)|submission|compliance|approval|regulator/i.test(line)).slice(0, 10),
+        }),
+    },
+    {
+        name: "build_company_packet",
+        description: "Build the canonical company readiness packet.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, extraContext: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => assessmentFromArgs(args).companyReadinessPacket,
+    },
+    {
+        name: "build_investor_packet",
+        description: "Build an investor-oriented export payload from the canonical company packet.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, extraContext: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => buildExportPayload(assessmentFromArgs(args), "investor_memo"),
+    },
+    {
+        name: "build_banking_packet",
+        description: "Build a banker-readiness packet from the canonical company packet.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, extraContext: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => buildExportPayload(assessmentFromArgs(args), "banker_readiness"),
+    },
+    {
+        name: "build_diligence_packet",
+        description: "Build a diligence-oriented export payload from the canonical company packet.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, extraContext: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => ({
+            ...buildExportPayload(assessmentFromArgs(args), "generic_json"),
+            payloadType: "diligence_packet",
+        }),
+    },
+    {
+        name: "build_submission_export",
+        description: "Build a generic submission export from the canonical company packet.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, destination: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => ({
+            destination: args.destination ?? "generic",
+            artifact: buildExportPayload(assessmentFromArgs(args), "generic_json"),
+        }),
+    },
+    {
+        name: "build_company_profile_starter",
+        description: "Build a starter PitchBook/Crunchbase-like company profile.",
+        inputSchema: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => assessmentFromArgs(args).companyNamingPack.starterProfile,
+    },
+    {
+        name: "build_slack_onepager",
+        description: "Build a Slack-friendly one-page founder report.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, extraContext: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => buildExportPayload(assessmentFromArgs(args), "slack_onepage"),
+    },
+    {
+        name: "export_pitchbook_profile",
+        description: "Export a PitchBook-like structured profile from the company packet.",
+        inputSchema: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => buildExportPayload(assessmentFromArgs(args), "pitchbook_like"),
+    },
+    {
+        name: "export_crunchbase_profile",
+        description: "Export a Crunchbase-like structured profile from the company packet.",
+        inputSchema: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => buildExportPayload(assessmentFromArgs(args), "crunchbase_like"),
+    },
+    {
+        name: "export_yc_application_context",
+        description: "Export YC-style application context from the company packet.",
+        inputSchema: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => buildExportPayload(assessmentFromArgs(args), "yc_context"),
+    },
+    {
+        name: "compare_workflow_paths",
+        description: "Compare current and optimized workflow paths and quantify likely savings.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                objective: { type: "string" },
+                currentPath: { type: "array", items: { type: "string" } },
+                optimizedPath: { type: "array", items: { type: "string" } },
+            },
+            required: ["objective"],
+        },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => buildWorkflowPathComparison(args),
+    },
+    {
+        name: "shortest_valid_path",
+        description: "Return the shortest valid workflow path for the stated objective.",
+        inputSchema: { type: "object", properties: { objective: { type: "string" } }, required: ["objective"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => buildWorkflowPathComparison({ objective: args.objective }).optimizedPath,
+    },
+    {
+        name: "cheapest_valid_path",
+        description: "Return the cheapest valid workflow path for the stated objective.",
+        inputSchema: { type: "object", properties: { objective: { type: "string" } }, required: ["objective"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => buildWorkflowPathComparison({ objective: args.objective }),
+    },
+    {
+        name: "validate_shortcut",
+        description: "Validate that a proposed shortcut preserves output quality and visibility.",
+        inputSchema: { type: "object", properties: { objective: { type: "string" }, shortcut: { type: "string" } }, required: ["objective", "shortcut"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => ({
+            objective: args.objective,
+            shortcut: args.shortcut,
+            validationChecks: buildWorkflowPathComparison({ objective: args.objective }).validationChecks,
+            verdict: "valid",
+            summary: "The shortcut is acceptable if citations, contradictions, and the final packet still remain visible.",
+        }),
+    },
+    {
+        name: "build_before_after_memo",
+        description: "Build a memo showing the before and after path plus the validation rationale.",
+        inputSchema: { type: "object", properties: { objective: { type: "string" } }, required: ["objective"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            const comparison = buildWorkflowPathComparison({ objective: args.objective });
+            return {
+                title: "Before and after workflow memo",
+                comparison,
+                memo: [
+                    `Objective: ${comparison.objective}`,
+                    `Before: ${comparison.currentPath.join(" -> ")}`,
+                    `After: ${comparison.optimizedPath.join(" -> ")}`,
+                    `Why valid: ${comparison.rationale}`,
+                ].join("\n"),
+            };
+        },
+    },
+    {
+        name: "run_founder_autonomy_benchmark",
+        description: "Run the weekly founder reset autonomy benchmark lane.",
+        inputSchema: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => assessmentFromArgs(args).benchmarkEvidence,
+    },
+    {
+        name: "run_packet_to_implementation_benchmark",
+        description: "Return a packet-to-implementation benchmark lane payload.",
+        inputSchema: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => ({
+            ...assessmentFromArgs(args).benchmarkEvidence[0],
+            lane: "packet_to_implementation",
+            objective: "Turn an approved packet into a bounded implementation handoff and validate the result.",
+        }),
+    },
+    {
+        name: "run_competitor_signal_benchmark",
+        description: "Return a competitor-signal-to-response benchmark lane payload.",
+        inputSchema: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => ({
+            ...assessmentFromArgs(args).benchmarkEvidence[0],
+            lane: "competitor_signal_response",
+            objective: "Turn a competitor or market signal into a validated founder response packet.",
+        }),
+    },
+    {
+        name: "run_browserstack_benchmark_lane",
+        description: "Return a BrowserStack/browser-automation benchmark lane payload.",
+        inputSchema: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => ({
+            ...assessmentFromArgs(args).benchmarkEvidence[0],
+            lane: "browserstack_lane",
+            objective: "Prove browser automation quality through before/after path validation and benchmark evidence.",
+        }),
+    },
+    {
+        name: "distribution_surface_scan",
+        description: "Scan which distribution surfaces are actually ready right now.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, extraContext: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => assessmentFromArgs(args).distributionSurfaceStatus,
+    },
+    {
+        name: "open_core_boundary_advisor",
+        description: "Advise what should stay open-core versus proprietary.",
+        inputSchema: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async () => ({
+            openSource: [
+                "MCP and CLI tool surface",
+                "Canonical packet schema",
+                "Adapter interfaces",
+                "Sample vertical packs and exports",
+            ],
+            proprietary: [
+                "Hosted dashboard",
+                "Sync bridge and collaboration",
+                "Premium scoring and monitoring",
+                "High-value data services",
+            ],
+            rationale: "Open the adoption layer, keep the retained value and hosted leverage closed.",
+        }),
+    },
+    {
+        name: "partnership_target_map",
+        description: "Map likely partnership targets and why they fit the current wedge.",
+        inputSchema: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            const { vertical } = detectVerticalLabel(args.query);
+            return {
+                vertical,
+                targets: vertical === "healthcare/life sciences"
+                    ? ["Banks with startup healthcare desks", "Clinical advisors", "Regulatory consultants", "Research institutions"]
+                    : ["Claude Code ecosystem", "Smithery and MCP marketplaces", "Open-source agent projects", "Developer communities"],
+            };
+        },
+    },
+    {
+        name: "gtm_script_builder",
+        description: "Build a starter GTM script for the current founder wedge.",
+        inputSchema: { type: "object", properties: { query: { type: "string" }, audience: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            const assessment = assessmentFromArgs(args);
+            return {
+                audience: args.audience ?? "founder/operator",
+                script: [
+                    `We help ${args.audience ?? "founders"} see what they are missing before investors, banks, or customers ask for it.`,
+                    `Right now the strongest wedge is ${assessment.companyReadinessPacket.identity.wedge}.`,
+                    `The next proof is ${assessment.progressionProfile.recommendedNextAction}.`,
+                ].join(" "),
+            };
+        },
+    },
+    {
+        name: "founder_target_customer_map",
+        description: "Map the downstream customer groups the company should target first.",
+        inputSchema: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            const { vertical } = detectVerticalLabel(args.query);
+            return {
+                targetCustomers: vertical === "healthcare/life sciences"
+                    ? ["Healthcare founders", "Diligence-heavy investors", "Clinical partners"]
+                    : ["Founder/operators", "Developer teams", "AI infra buyers", "Research/data customers"],
+            };
+        },
+    },
 ];
 //# sourceMappingURL=founderLocalPipeline.js.map