@sprinterai/runtime 0.5.0 → 0.7.1

package/dist/tool/gallery/gallery-tools.js

@@ -0,0 +1,971 @@
+/**
+ * Gallery tools — executable ToolDefinition implementations for all 17
+ * interactive demo tools. Each tool has a Zod input schema and an
+ * async execute function that performs the computation logic.
+ *
+ * These complement gallery-tool-definitions.ts (which provides JSON Schema
+ * metadata for seeding the database / rendering forms).
+ */
+import { defineTool } from '@sprinterai/core';
+import { z } from 'zod';
+// ── Roofing & Home Services ──────────────────────────────────────────
+const roofReadinessCheck = defineTool({
+    slug: 'roof-readiness-check',
+    name: 'Roof Readiness Check',
+    description: 'Help homeowners understand if they likely need repair, replacement, or a professional inspection first.',
+    category: 'roofing',
+    icon: 'home',
+    inputSchema: z.object({
+        roofAge: z.enum(['Under 10 years', '10–19 years', '20–24 years', '25+ years']),
+        symptom: z.enum([
+            'Granule loss / cosmetic wear',
+            'Missing shingles or flashing concern',
+            'Active leak or interior staining',
+            'Sagging / structural concern',
+        ]),
+        stormStatus: z.enum([
+            'No known storm event',
+            'Storm damage suspected',
+            'Known storm / claim discussion',
+        ]),
+        timeline: z.enum(['Just exploring', 'This month', 'This week', 'Need help immediately']),
+    }),
+    async execute(raw) {
+        const input = raw;
+        const ageScores = {
+            'Under 10 years': 1,
+            '10–19 years': 1,
+            '20–24 years': 2,
+            '25+ years': 3,
+        };
+        const symptomScores = {
+            'Granule loss / cosmetic wear': 1,
+            'Missing shingles or flashing concern': 2,
+            'Active leak or interior staining': 4,
+            'Sagging / structural concern': 5,
+        };
+        const stormScores = {
+            'No known storm event': 0,
+            'Storm damage suspected': 2,
+            'Known storm / claim discussion': 3,
+        };
+        const timelineScores = {
+            'Just exploring': 0,
+            'This month': 1,
+            'This week': 2,
+            'Need help immediately': 3,
+        };
+        const score = (ageScores[input.roofAge] ?? 0) +
+            (symptomScores[input.symptom] ?? 0) +
+            (stormScores[input.stormStatus] ?? 0) +
+            (timelineScores[input.timeline] ?? 0);
+        const urgency = score >= 9 ? 'High' : score >= 5 ? 'Medium' : 'Low';
+        const path = urgency === 'High'
+            ? 'Replacement review'
+            : urgency === 'Medium'
+                ? 'Inspection + insurance review'
+                : 'Repair-first consult';
+        return { urgency, likelyPath: path, score, summary: `${urgency} urgency — ${path}` };
+    },
+});
+const projectBudgetEstimator = defineTool({
+    slug: 'project-budget-estimator',
+    name: 'Project Budget Estimator',
+    description: 'Give homeowners a rough project cost band before they ever talk to sales.',
+    category: 'roofing',
+    icon: 'calculator',
+    inputSchema: z.object({
+        squares: z.coerce.number().min(12).max(60),
+        material: z.enum([
+            'Architectural shingle',
+            'Premium shingle',
+            'Standing seam metal',
+            'Tile / specialty roof',
+        ]),
+        complexity: z.enum([
+            'Simple roofline',
+            'Moderate tear-off / complexity',
+            'Steep pitch / complex details',
+        ]),
+        insuranceCredit: z.enum([
+            'No claim contribution',
+            '$3,000 contribution',
+            '$7,000 contribution',
+            '$12,000 contribution',
+        ]),
+    }),
+    async execute(raw) {
+        const input = raw;
+        const baseRates = {
+            'Architectural shingle': 540,
+            'Premium shingle': 760,
+            'Standing seam metal': 1040,
+            'Tile / specialty roof': 1460,
+        };
+        const multipliers = {
+            'Simple roofline': 1.0,
+            'Moderate tear-off / complexity': 1.12,
+            'Steep pitch / complex details': 1.28,
+        };
+        const credits = {
+            'No claim contribution': 0,
+            '$3,000 contribution': 3000,
+            '$7,000 contribution': 7000,
+            '$12,000 contribution': 12000,
+        };
+        const baseRate = baseRates[input.material] ?? 540;
+        const multiplier = multipliers[input.complexity] ?? 1.0;
+        const credit = credits[input.insuranceCredit] ?? 0;
+        const subtotal = input.squares * baseRate * multiplier;
+        const low = Math.round(subtotal * 0.92 - credit);
+        const high = Math.round(subtotal * 1.08 - credit);
+        return {
+            estimatedRange: `$${low.toLocaleString()} – $${high.toLocaleString()}`,
+            material: input.material,
+            complexity: input.complexity,
+            insuranceCredit: `$${credit.toLocaleString()}`,
+        };
+    },
+});
+// ── Mortgage & Lending ───────────────────────────────────────────────
+const borrowerScenarioStudio = defineTool({
+    slug: 'borrower-scenario-studio',
+    name: 'Borrower Scenario Studio',
+    description: 'Let borrowers test the real impact of rate, down payment, and timeline changes on their monthly payment.',
+    category: 'mortgage',
+    icon: 'landmark',
+    inputSchema: z.object({
+        purchasePrice: z.coerce.number().min(250000).max(1200000),
+        downPaymentPct: z.coerce.number().min(3).max(30),
+        creditRange: z.enum(['660–699', '700–719', '720–739', '740+']),
+        timeline: z.enum(['30 days', '60 days', '90 days', '6+ months']),
+    }),
+    async execute(raw) {
+        const input = raw;
+        const baseRate = 6.55;
+        const creditAdj = {
+            '660–699': 0.6,
+            '700–719': 0.28,
+            '720–739': 0,
+            '740+': -0.15,
+        };
+        const dpAdj = input.downPaymentPct >= 20 ? -0.22 : input.downPaymentPct >= 10 ? 0 : 0.18;
+        const rate = baseRate + (creditAdj[input.creditRange] ?? 0) + dpAdj;
+        const loanAmount = input.purchasePrice * (1 - input.downPaymentPct / 100);
+        const monthlyRate = rate / 100 / 12;
+        const n = 360;
+        const payment = Math.round((loanAmount * (monthlyRate * Math.pow(1 + monthlyRate, n))) /
+            (Math.pow(1 + monthlyRate, n) - 1));
+        const taxes = Math.round((input.purchasePrice * 0.012) / 12);
+        const insurance = Math.round((input.purchasePrice * 0.0035) / 12);
+        const total = payment + taxes + insurance;
+        const readiness = rate < 6.5 ? 'Strong' : rate < 7 ? 'Workable' : 'Needs structuring';
+        return {
+            estimatedMonthlyPayment: `$${(total - 140).toLocaleString()} – $${(total + 140).toLocaleString()}`,
+            rate: `${rate.toFixed(3)}%`,
+            loanAmount: `$${loanAmount.toLocaleString()}`,
+            readiness,
+        };
+    },
+});
+const refiSavingsAudit = defineTool({
+    slug: 'refi-savings-audit',
+    name: 'Refi Savings Audit',
+    description: 'Help homeowners see whether a refinance conversation is worth having now.',
+    category: 'mortgage',
+    icon: 'percent',
+    inputSchema: z.object({
+        currentBalance: z.coerce.number().min(150000).max(900000),
+        currentRate: z.enum(['6.125%', '6.500%', '6.875%', '7.250%']),
+        homeValue: z.coerce.number().min(250000).max(1200000),
+        cashOutGoal: z.enum(['No cash-out', '$25,000', '$50,000', '$75,000']),
+    }),
+    async execute(raw) {
+        const input = raw;
+        const rate = parseFloat(input.currentRate);
+        const cashOutMap = {
+            'No cash-out': 0,
+            '$25,000': 25000,
+            '$50,000': 50000,
+            '$75,000': 75000,
+        };
+        const cashOut = cashOutMap[input.cashOutGoal] ?? 0;
+        const ltv = (input.currentBalance + cashOut) / input.homeValue;
+        const rateReduction = ltv <= 0.6 ? 0.75 : ltv <= 0.8 ? 0.5 : 0.25;
+        const cashPenalty = cashOut >= 75000 ? 0.2 : cashOut >= 25000 ? 0.1 : 0;
+        const newRate = Math.max(5.625, rate - rateReduction + cashPenalty);
+        const monthlyRate = rate / 100 / 12;
+        const newMonthlyRate = newRate / 100 / 12;
+        const n = 360;
+        const currentPayment = (input.currentBalance * (monthlyRate * Math.pow(1 + monthlyRate, n))) /
+            (Math.pow(1 + monthlyRate, n) - 1);
+        const newPayment = ((input.currentBalance + cashOut) * (newMonthlyRate * Math.pow(1 + newMonthlyRate, n))) /
+            (Math.pow(1 + newMonthlyRate, n) - 1);
+        const delta = Math.round(currentPayment - newPayment);
+        const breakEven = delta > 0 ? Math.round(4800 / delta) : null;
+        const recommendation = delta > 100 ? 'Worth a live review' : 'Monitor and revisit';
+        return {
+            monthlySavings: `$${delta}/mo`,
+            newRate: `${newRate.toFixed(3)}%`,
+            breakEvenMonths: breakEven,
+            recommendation,
+        };
+    },
+});
+// ── Building Products ────────────────────────────────────────────────
+const materialMatchSelector = defineTool({
+    slug: 'material-match-selector',
+    name: 'Material Match Selector',
+    description: 'Guide specifiers to the right product family based on environment, budget, and install constraints.',
+    category: 'building-products',
+    icon: 'layers',
+    inputSchema: z.object({
+        application: z.enum([
+            'Exterior cladding',
+            'Multifamily retrofit',
+            'Commercial interior',
+            'Residential finish package',
+        ]),
+        environment: z.enum([
+            'Coastal / humidity-heavy',
+            'Freeze-thaw exposure',
+            'Standard weather exposure',
+            'Interior / dry environment',
+        ]),
+        budget: z.enum(['Value-focused', 'Mid-range', 'Premium']),
+        priority: z.enum([
+            'Low maintenance',
+            'Design flexibility',
+            'Install speed',
+            'Cleaner code path',
+        ]),
+    }),
+    async execute(raw) {
+        const input = raw;
+        let result;
+        if (input.application.includes('interior') && input.priority === 'Design flexibility') {
+            // "Commercial interior" includes 'interior'
+            result = 'Architectural wall panel system';
+        }
+        else if (input.application.includes('retrofit') && input.priority === 'Install speed') {
+            // "Multifamily retrofit" includes 'retrofit'
+            result = 'Panelized retrofit cladding system';
+        }
+        else if (input.budget === 'Premium' && input.priority === 'Design flexibility') {
+            result = 'Powder-coated aluminum panel';
+        }
+        else {
+            result = 'Fiber-cement rainscreen panel';
+        }
+        return {
+            recommendedFamily: result,
+            application: input.application,
+            environment: input.environment,
+            priority: input.priority,
+        };
+    },
+});
+const specReadinessAudit = defineTool({
+    slug: 'spec-readiness-audit',
+    name: 'Spec Readiness Audit',
+    description: 'Expose missing inputs before an architect or contractor sends an incomplete request.',
+    category: 'building-products',
+    icon: 'clipboard-check',
+    inputSchema: z.object({
+        projectType: z.enum([
+            'Multifamily retrofit',
+            'New commercial build',
+            'Tenant improvement',
+            'Custom residential',
+        ]),
+        substrateStatus: z.enum(['Unknown', 'Assumed but unverified', 'Confirmed']),
+        installMethod: z.enum([
+            'Undecided',
+            'Direct attach',
+            'Clip / rail system',
+            'Panelized assembly',
+        ]),
+        compliance: z.enum([
+            'Standard code review',
+            'NFPA / fire path needed',
+            'Acoustic performance needed',
+            'Energy / envelope focus',
+        ]),
+    }),
+    async execute(raw) {
+        const input = raw;
+        const gaps = [];
+        if (input.substrateStatus !== 'Confirmed') {
+            gaps.push('Substrate and assembly confirmation');
+        }
+        if (input.installMethod === 'Undecided') {
+            gaps.push('Install method / attachment path');
+        }
+        if (input.compliance.includes('NFPA')) {
+            gaps.push('Fire / assembly documentation package');
+        }
+        if (input.projectType.includes('retrofit')) {
+            gaps.push('Existing wall condition verification');
+        }
+        return {
+            readiness: gaps.length === 0 ? 'Ready' : `${gaps.length} items missing`,
+            missingItems: gaps,
+            topGap: gaps[0] ?? 'None',
+        };
+    },
+});
+// ── Legal Intake ─────────────────────────────────────────────────────
+const matterFitScreener = defineTool({
+    slug: 'matter-fit-screener',
+    name: 'Matter Fit Screener',
+    description: 'Let prospects understand likely case fit before waiting on a callback.',
+    category: 'legal-intake',
+    icon: 'scale',
+    inputSchema: z.object({
+        practiceArea: z.enum(['Personal Injury', 'Employment', 'Immigration', 'Consumer Protection']),
+        incidentType: z.enum([
+            'Auto accident',
+            'Workplace injury',
+            'Product liability',
+            'Wrongful termination',
+            'Wage / hour dispute',
+            'Visa application',
+            'Billing or contract dispute',
+            'Other',
+        ]),
+        timeline: z.enum(['Less than 30 days', '30–90 days', 'More than 90 days', 'No deadline yet']),
+        evidence: z.enum([
+            'None gathered yet',
+            'Some (photos, records, etc.)',
+            'Extensive documentation',
+        ]),
+    }),
+    async execute(raw) {
+        const input = raw;
+        const practiceScores = {
+            'Personal Injury': 4,
+            Employment: 3,
+            Immigration: 2,
+            'Consumer Protection': 2,
+        };
+        const incidentScores = {
+            'Auto accident': 4,
+            'Workplace injury': 3,
+            'Product liability': 3,
+            'Wrongful termination': 3,
+            'Wage / hour dispute': 2,
+            'Visa application': 2,
+        };
+        const timelineScores = {
+            'Less than 30 days': 4,
+            '30–90 days': 3,
+            'More than 90 days': 1,
+            'No deadline yet': 2,
+        };
+        const evidenceScores = {
+            'None gathered yet': 0,
+            'Some (photos, records, etc.)': 2,
+            'Extensive documentation': 4,
+        };
+        const total = (practiceScores[input.practiceArea] ?? 0) +
+            (incidentScores[input.incidentType] ?? 1) +
+            (timelineScores[input.timeline] ?? 0) +
+            (evidenceScores[input.evidence] ?? 0);
+        const tier = total >= 11 ? 'Strong' : total >= 7 ? 'Possible' : 'Unlikely';
+        const path = tier === 'Strong'
+            ? 'Priority attorney review'
+            : tier === 'Possible'
+                ? 'Standard intake callback'
+                : 'Self-service resources';
+        return { fitTier: tier, intakePath: path, score: total };
+    },
+});
+// ── Healthcare & Clinics ─────────────────────────────────────────────
+const consultReadinessNavigator = defineTool({
+    slug: 'consult-readiness-navigator',
+    name: 'Consult Readiness Navigator',
+    description: 'Guide patients through fit, timing, and expectation questions before they book a consultation.',
+    category: 'clinics',
+    icon: 'stethoscope',
+    inputSchema: z.object({
+        category: z.enum(['Aesthetics / MedSpa', 'Dental', 'Sports Medicine', 'Functional Medicine']),
+        concern: z.enum([
+            'Body contouring',
+            'Skin rejuvenation',
+            'Injectables / fillers',
+            'Laser treatments',
+            'Cosmetic dentistry',
+            'Implants',
+            'Orthodontics',
+            'Restorative',
+            'Injury rehabilitation',
+            'Performance optimization',
+            'Chronic pain management',
+            'Surgical consultation',
+            'Hormone optimization',
+            'Gut health',
+            'Autoimmune support',
+            'Longevity / wellness',
+        ]),
+        budget: z.enum(['$500–$1,500', '$1,500–$5,000', '$5,000+']),
+        urgency: z.enum(['Exploring (3+ months)', 'Planning (1–3 months)', 'Ready now']),
+    }),
+    async execute(raw) {
+        const input = raw;
+        const catScores = {
+            'Aesthetics / MedSpa': 3,
+            Dental: 3,
+            'Sports Medicine': 2,
+            'Functional Medicine': 2,
+        };
+        const budgetScores = {
+            '$500–$1,500': 1,
+            '$1,500–$5,000': 3,
+            '$5,000+': 4,
+        };
+        const urgencyScores = {
+            'Exploring (3+ months)': 1,
+            'Planning (1–3 months)': 3,
+            'Ready now': 4,
+        };
+        const total = (catScores[input.category] ?? 0) +
+            (budgetScores[input.budget] ?? 0) +
+            (urgencyScores[input.urgency] ?? 0);
+        const fit = total >= 9 ? 'High' : total >= 6 ? 'Medium' : 'Low';
+        const serviceTier = input.budget.includes('5,000+')
+            ? 'Premium'
+            : input.budget.includes('1,500')
+                ? 'Standard'
+                : 'Introductory';
+        const nextStep = fit === 'High'
+            ? 'Book priority consultation'
+            : fit === 'Medium'
+                ? 'Schedule discovery call'
+                : 'Review resources';
+        return {
+            fitScore: fit,
+            serviceTier,
+            nextStep,
+            category: input.category,
+            concern: input.concern,
+        };
+    },
+});
+// ── Recruiting & Staffing ────────────────────────────────────────────
+const candidateFitSnapshot = defineTool({
+    slug: 'candidate-fit-snapshot',
+    name: 'Candidate Fit Snapshot',
+    description: 'Show candidates how well they match a role before a recruiter spends live time.',
+    category: 'staffing',
+    icon: 'user-check',
+    inputSchema: z.object({
+        roleType: z.enum(['Technology', 'Finance / Accounting', 'Operations', 'Creative / Marketing']),
+        experience: z.enum(['0–2 years', '3–7 years', '8–15 years', '15+ years']),
+        workPref: z.enum(['Remote', 'Hybrid', 'Onsite', 'Flexible']),
+        startTimeline: z.enum(['Immediately', 'Within 30 days', '60+ days']),
+    }),
+    async execute(raw) {
+        const input = raw;
+        const roleScores = {
+            Technology: 3,
+            'Finance / Accounting': 3,
+            Operations: 2,
+            'Creative / Marketing': 2,
+        };
+        const expScores = {
+            '0–2 years': 1,
+            '3–7 years': 3,
+            '8–15 years': 4,
+            '15+ years': 3,
+        };
+        const workScores = {
+            Remote: 2,
+            Hybrid: 3,
+            Onsite: 2,
+            Flexible: 4,
+        };
+        const startScores = {
+            Immediately: 4,
+            'Within 30 days': 3,
+            '60+ days': 1,
+        };
+        const rawScore = (roleScores[input.roleType] ?? 0) +
+            (expScores[input.experience] ?? 0) +
+            (workScores[input.workPref] ?? 0) +
+            (startScores[input.startTimeline] ?? 0);
+        const matchScore = Math.min(10, Math.round((rawScore / 15) * 10 * 10) / 10);
+        const tier = matchScore >= 8 ? 'Hot' : matchScore >= 5.5 ? 'Warm' : 'Cool';
+        const timeToPlace = tier === 'Hot' ? '2–4 weeks' : tier === 'Warm' ? '4–8 weeks' : '8+ weeks';
+        return {
+            matchScore,
+            tier,
+            estimatedTimeToPlacement: timeToPlace,
+            roleType: input.roleType,
+            experience: input.experience,
+        };
+    },
+});
+// ── Tax Advisory ─────────────────────────────────────────────────────
+const taxStrategySnapshot = defineTool({
+    slug: 'tax-strategy-snapshot',
+    name: 'Tax Strategy Snapshot',
+    description: 'Help business owners gauge whether there is meaningful strategy upside before a paid advisory conversation.',
+    category: 'tax-advisory',
+    icon: 'receipt',
+    inputSchema: z.object({
+        entityType: z.enum(['Sole Proprietorship', 'LLC', 'S-Corp', 'C-Corp']),
+        revenue: z.enum(['Under $500k', '$500k–$1M', '$1M–$3M', '$3M+']),
+        compStyle: z.enum(['W-2 only', 'W-2 + distributions', 'Distributions only', '1099 only']),
+        multiState: z.enum(['One state', 'Two states', 'Three or more states']),
+    }),
+    async execute(raw) {
+        const input = raw;
+        const entityScores = {
+            'Sole Proprietorship': 4,
+            LLC: 3,
+            'S-Corp': 2,
+            'C-Corp': 1,
+        };
+        const revScores = {
+            'Under $500k': 1,
+            '$500k–$1M': 2,
+            '$1M–$3M': 3,
+            '$3M+': 4,
+        };
+        const compScores = {
+            'W-2 only': 1,
+            'W-2 + distributions': 3,
+            'Distributions only': 4,
+            '1099 only': 4,
+        };
+        const stateScores = {
+            'One state': 0,
+            'Two states': 2,
+            'Three or more states': 3,
+        };
+        const total = (entityScores[input.entityType] ?? 0) +
+            (revScores[input.revenue] ?? 0) +
+            (compScores[input.compStyle] ?? 0) +
+            (stateScores[input.multiState] ?? 0);
+        const tier = total >= 10 ? 'High' : total >= 6 ? 'Moderate' : 'Low';
+        const revMap = {
+            'Under $500k': 500000,
+            '$500k–$1M': 750000,
+            '$1M–$3M': 2000000,
+            '$3M+': 4000000,
+        };
+        const revNum = revMap[input.revenue] ?? 500000;
+        const low = Math.round(revNum * 0.018);
+        const high = Math.round(revNum * 0.042);
+        return {
+            opportunityTier: tier,
+            upsideRange: `$${low.toLocaleString()} – $${high.toLocaleString()}`,
+            score: total,
+        };
+    },
+});
+const entityChoicePlanner = defineTool({
+    slug: 'entity-choice-planner',
+    name: 'Entity Choice Planner',
+    description: 'Give business owners a better starting point for entity and compensation structure conversations.',
+    category: 'tax-advisory',
+    icon: 'building',
+    inputSchema: z.object({
+        currentEntity: z.enum(['Sole Proprietorship', 'LLC', 'S-Corp', 'C-Corp']),
+        netProfit: z.coerce.number().min(50000).max(1000000),
+        ownerGoal: z.enum(['Reduce taxes', 'Fund growth', 'Plan exit', 'Protect assets']),
+        hiringPlans: z.enum(['Staying solo', 'Hiring soon', 'Already have employees']),
+    }),
+    async execute(raw) {
+        const input = raw;
+        let recommendation = 'S-Corp election';
+        if (input.currentEntity === 'S-Corp') {
+            recommendation = 'Optimize existing S-Corp structure';
+        }
+        else if (input.currentEntity === 'C-Corp') {
+            recommendation = 'Consult on C-Corp tradeoffs';
+        }
+        else if (input.hiringPlans === 'Hiring soon' && input.netProfit > 300000) {
+            recommendation = 'S-Corp + profit-sharing plan';
+        }
+        const currentSE = input.netProfit * 0.153 * 0.9235;
+        let savings = Math.round(currentSE * 0.35);
+        if (input.currentEntity === 'S-Corp') {
+            savings = Math.round(input.netProfit * 0.04);
+        }
+        if (input.hiringPlans === 'Hiring soon' && input.netProfit > 300000) {
+            savings = Math.round(input.netProfit * 0.12);
+        }
+        if (input.currentEntity === 'C-Corp') {
+            savings = 0;
+        }
+        const low = Math.round(savings * 0.8);
+        const high = Math.round(savings * 1.2);
+        return {
+            recommendation,
+            estimatedSavings: savings > 0
+                ? `$${low.toLocaleString()} – $${high.toLocaleString()}`
+                : 'Structure-dependent',
+            currentEntity: input.currentEntity,
+            netProfit: `$${input.netProfit.toLocaleString()}`,
+        };
+    },
+});
+// ── Industrial Quotes ────────────────────────────────────────────────
+const rfqReadinessBuilder = defineTool({
+    slug: 'rfq-readiness-builder',
+    name: 'RFQ Readiness Builder',
+    description: 'Help buyers gather the right technical details before they ask for a quote.',
+    category: 'industrial-quotes',
+    icon: 'clipboard-list',
+    inputSchema: z.object({
+        application: z.enum(['Conveyor drive', 'Pump drive', 'Mixer', 'Fan / blower', 'General']),
+        capacity: z.enum(['Light', 'Moderate', 'Heavy', 'Severe']),
+        environment: z.enum(['Indoor / clean', 'Outdoor / dusty', 'Washdown', 'Hazardous']),
+        timeline: z.enum(['2 weeks', '4 weeks', '8 weeks', 'Flexible']),
+    }),
+    async execute(raw) {
+        const input = raw;
+        const gaps = [];
+        if (input.application === 'Conveyor drive') {
+            gaps.push('Center-to-center distance');
+            gaps.push('Mounting orientation');
+        }
+        else if (input.application === 'Pump drive') {
+            gaps.push('Fluid type / specific gravity');
+            gaps.push('NPSH requirements');
+        }
+        else if (input.application === 'Mixer') {
+            gaps.push('Impeller diameter');
+            gaps.push('Liquid viscosity');
+        }
+        else {
+            gaps.push('Service factor');
+            gaps.push('Overload class');
+        }
+        if (input.environment === 'Outdoor / dusty') {
+            gaps.push('IP/NEMA enclosure rating');
+        }
+        if (input.environment === 'Washdown') {
+            gaps.push('NSF/FDA compliance documentation');
+        }
+        if (input.environment === 'Hazardous') {
+            gaps.push('ATEX/NEC hazard classification');
+        }
+        const urgent = input.timeline === '2 weeks' || input.timeline === '4 weeks';
+        const readiness = gaps.length <= 1
+            ? 'Ready to quote'
+            : gaps.length <= 3
+                ? `Mostly ready — ${gaps.length} inputs missing`
+                : `Needs more detail — ${gaps.length} inputs missing`;
+        return {
+            readiness,
+            missingInputs: gaps,
+            urgent,
+            topMissing: gaps[0] ?? 'None',
+        };
+    },
+});
+const productFamilyShortlist = defineTool({
+    slug: 'product-family-shortlist',
+    name: 'Product Family Shortlist',
+    description: 'Guide buyers toward the right product family before a sales engineer gets involved.',
+    category: 'industrial-quotes',
+    icon: 'cog',
+    inputSchema: z.object({
+        industry: z.enum([
+            'Material handling',
+            'Food & beverage',
+            'Aggregate',
+            'Chemical',
+            'General manufacturing',
+        ]),
+        useCase: z.enum([
+            'Moderate shock',
+            'Severe shock',
+            'Low-speed / high-torque',
+            'Variable speed',
+        ]),
+        dutyLevel: z.enum(['Light', 'Standard', 'Heavy']),
+        constraint: z.enum(['Compact envelope', 'NEMA 4X', 'Budget priority', 'Lead time priority']),
+    }),
+    async execute(raw) {
+        const input = raw;
+        let family;
+        if (input.constraint === 'NEMA 4X' && input.dutyLevel !== 'Light') {
+            family = 'Shaft-mount with NEMA 4X enclosure';
+        }
+        else if (input.useCase === 'Severe shock') {
+            family = 'Heavy-duty parallel shaft reducer';
+        }
+        else if (input.useCase === 'Low-speed / high-torque') {
+            family = 'Planetary gear reducer';
+        }
+        else if (input.industry === 'Food & beverage') {
+            family = 'Food-grade stainless reducer';
+        }
+        else if (input.industry === 'Aggregate') {
+            family = 'Heavy-duty shaft-mount with backstop';
+        }
+        else {
+            family = 'Inline helical gear reducer';
+        }
+        return {
+            recommendedFamily: family,
+            industry: input.industry,
+            useCase: input.useCase,
+            constraint: input.constraint,
+        };
+    },
+});
+// ── Realtor Teams ────────────────────────────────────────────────────
+const moveReadinessPlanner = defineTool({
+    slug: 'move-readiness-planner',
+    name: 'Move Readiness Planner',
+    description: 'Show buyers and sellers what to do next based on timing, budget, and urgency.',
+    category: 'realtor-teams',
+    icon: 'map-pin',
+    inputSchema: z.object({
+        moveType: z.enum(['Sell and buy', 'Sell only', 'Buy only', 'Rent first']),
+        timeline: z.enum(['1 month', '3 months', '6 months', 'Exploring']),
+        equity: z.coerce.number().min(0).max(800000),
+        prepStatus: z.enum(['Ready now', 'Light prep needed', 'Staging needed', 'Major work required']),
+    }),
+    async execute(raw) {
+        const input = raw;
+        const moveScores = {
+            'Buy only': 3,
+            'Sell only': 3,
+            'Sell and buy': 2,
+            'Rent first': 1,
+        };
+        const timeScores = {
+            '1 month': 4,
+            '3 months': 3,
+            '6 months': 2,
+            Exploring: 1,
+        };
+        const equityScore = input.equity >= 200000 ? 3 : input.equity >= 100000 ? 2 : 1;
+        const prepScores = {
+            'Ready now': 4,
+            'Light prep needed': 3,
+            'Staging needed': 2,
+            'Major work required': 1,
+        };
+        const total = (moveScores[input.moveType] ?? 0) +
+            (timeScores[input.timeline] ?? 0) +
+            equityScore +
+            (prepScores[input.prepStatus] ?? 0);
+        const readiness = total >= 11 ? 'Strong readiness' : total >= 7 ? 'On track — minor items' : 'Plan first';
+        const netProceeds = Math.round(input.equity * 0.93);
+        return {
+            readiness,
+            score: total,
+            netProceeds: `$${netProceeds.toLocaleString()}`,
+            moveType: input.moveType,
+            timeline: input.timeline,
+        };
+    },
+});
+const offerStrengthCheck = defineTool({
+    slug: 'offer-strength-check',
+    name: 'Offer Strength Check',
+    description: 'Help buyers understand how competitive their likely offer position is before touring.',
+    category: 'realtor-teams',
+    icon: 'shield-check',
+    inputSchema: z.object({
+        downPayment: z.coerce.number().min(10000).max(500000),
+        preApproval: z.enum(['Not started', 'Pre-qualified', 'Pre-approved', 'Cash buyer']),
+        marketSpeed: z.enum(['Slow', 'Moderate', 'Fast', 'Bidding war']),
+        closingFlex: z.enum(['Flexible', 'Moderate', 'Constrained']),
+    }),
+    async execute(raw) {
+        const input = raw;
+        const dpScore = input.downPayment >= 200000
+            ? 4
+            : input.downPayment >= 100000
+                ? 3
+                : input.downPayment >= 50000
+                    ? 2
+                    : 1;
+        const approvalScores = {
+            'Cash buyer': 5,
+            'Pre-approved': 3,
+            'Pre-qualified': 1,
+            'Not started': 0,
+        };
+        const marketScores = {
+            Slow: 4,
+            Moderate: 3,
+            Fast: 2,
+            'Bidding war': 1,
+        };
+        const flexScores = {
+            Flexible: 3,
+            Moderate: 2,
+            Constrained: 1,
+        };
+        const approvalScore = approvalScores[input.preApproval] ?? 0;
+        const flexScore = flexScores[input.closingFlex] ?? 0;
+        const total = dpScore + approvalScore + (marketScores[input.marketSpeed] ?? 0) + flexScore;
+        const tier = total >= 13
+            ? 'Very competitive'
+            : total >= 9
+                ? 'Competitive'
+                : total >= 6
+                    ? 'Workable — gaps to fix'
+                    : 'Needs strengthening';
+        const weakness = approvalScore <= 1
+            ? 'Get pre-approved before competing'
+            : dpScore <= 2
+                ? 'Increase down payment for stronger position'
+                : flexScore <= 1
+                    ? 'Add closing flexibility'
+                    : 'Position looks solid';
+        return {
+            strengthTier: tier,
+            score: total,
+            primaryWeakness: weakness,
+            downPayment: `$${input.downPayment.toLocaleString()}`,
+        };
+    },
+});
+// ── Private Equity ───────────────────────────────────────────────────
+const diligenceReadinessScorecard = defineTool({
+    slug: 'diligence-readiness-scorecard',
+    name: 'Diligence Readiness Scorecard',
+    description: 'Expose operational gaps before a management team enters a live deal process.',
+    category: 'private-equity',
+    icon: 'bar-chart',
+    inputSchema: z.object({
+        companyType: z.enum(['SaaS', 'Services', 'Manufacturing', 'Distribution']),
+        reportingCadence: z.enum(['Weekly', 'Monthly', 'Quarterly', 'Ad-hoc']),
+        keymanRisk: z.enum(['None', 'Present', 'Severe']),
+        financialModel: z.enum(['Complete', 'Partial', 'None']),
+    }),
+    async execute(raw) {
+        const input = raw;
+        const gaps = [];
+        if (input.keymanRisk === 'Present' || input.keymanRisk === 'Severe') {
+            gaps.push('Key-man dependency');
+        }
+        if (input.financialModel === 'Partial') {
+            gaps.push('Incomplete financial model');
+        }
+        if (input.financialModel === 'None') {
+            gaps.push('No financial model (critical)');
+        }
+        if (input.reportingCadence === 'Quarterly' || input.reportingCadence === 'Ad-hoc') {
+            gaps.push('Infrequent reporting');
+        }
+        if (input.companyType === 'Services' || input.companyType === 'Manufacturing') {
+            gaps.push('Customer concentration risk');
+        }
+        if (input.companyType === 'SaaS') {
+            gaps.push('ARR/churn metrics needed');
+        }
+        const readiness = gaps.length === 0
+            ? 'Diligence-ready'
+            : gaps.length <= 2
+                ? `Moderate — ${gaps.length} gaps`
+                : `Needs work — ${gaps.length} gaps`;
+        const quickWin = input.financialModel !== 'Complete'
+            ? 'Complete the financial model'
+            : input.reportingCadence !== 'Weekly' && input.reportingCadence !== 'Monthly'
+                ? 'Move to monthly reporting'
+                : 'Prepare data room';
+        return {
+            readiness,
+            gapCount: gaps.length,
+            gaps,
+            quickWin,
+            topRisk: gaps[0] ?? 'None',
+        };
+    },
+});
+const portcoSignalBrief = defineTool({
+    slug: 'portco-signal-brief',
+    name: 'Portco Signal Brief',
+    description: 'Show portfolio teams how a lightweight signal monitor could work before full implementation.',
+    category: 'private-equity',
+    icon: 'activity',
+    inputSchema: z.object({
+        revenueTrend: z.enum(['Growing', 'Flat', 'Declining']),
+        headcountTrend: z.enum(['Growing', 'Stable', 'Decline', 'Rapid decline']),
+        churnLevel: z.enum(['Low', 'Elevated', 'High']),
+        reportingLag: z.enum(['Under 7 days', '7–14 days', '15+ days', '30+ days']),
+    }),
+    async execute(raw) {
+        const input = raw;
+        let score = 0;
+        const triggers = [];
+        if (input.revenueTrend === 'Declining') {
+            score += 3;
+            triggers.push('Revenue decline');
+        }
+        else if (input.revenueTrend === 'Flat') {
+            score += 1;
+        }
+        if (input.headcountTrend === 'Rapid decline') {
+            score += 3;
+            triggers.push('Headcount reduction');
+        }
+        else if (input.headcountTrend === 'Decline') {
+            score += 2;
+            triggers.push('Headcount reduction');
+        }
+        if (input.churnLevel === 'High') {
+            score += 3;
+            triggers.push('Customer churn');
+        }
+        else if (input.churnLevel === 'Elevated') {
+            score += 2;
+            triggers.push('Elevated churn');
+        }
+        if (input.reportingLag === '30+ days') {
+            score += 2;
+            triggers.push('Reporting lag');
+        }
+        else if (input.reportingLag === '15+ days') {
+            score += 1;
+        }
+        const status = score >= 6
+            ? 'Escalation recommended'
+            : score >= 3
+                ? 'Watchlist'
+                : 'Monitoring — no escalation';
+        const cadence = score >= 6
+            ? 'Weekly ops call for 60 days'
+            : score >= 3
+                ? 'Bi-weekly check-in + monthly deep-dive'
+                : 'Standard monthly reporting';
+        return {
+            status,
+            score,
+            triggers,
+            cadence,
+            primaryTrigger: triggers[0] ?? 'No active triggers',
+        };
+    },
+});
+// ── Export ────────────────────────────────────────────────────────────
+export const galleryTools = [
+    roofReadinessCheck,
+    projectBudgetEstimator,
+    borrowerScenarioStudio,
+    refiSavingsAudit,
+    materialMatchSelector,
+    specReadinessAudit,
+    matterFitScreener,
+    consultReadinessNavigator,
+    candidateFitSnapshot,
+    taxStrategySnapshot,
+    entityChoicePlanner,
+    rfqReadinessBuilder,
+    productFamilyShortlist,
+    moveReadinessPlanner,
+    offerStrengthCheck,
+    diligenceReadinessScorecard,
+    portcoSignalBrief,
+];
+//# sourceMappingURL=gallery-tools.js.map