@kynver-app/mcp-estimator 0.2.0 → 0.2.2

package/dist/index.js

@@ -5,7 +5,11 @@
  * Env: KYNVER_API_URL (default https://kynver.com), KYNVER_API_KEY (required for all tools)
  */
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { handleCliVersionFlag } from "./lib/package-version.js";
 import { createEstimatorServer } from "./server.js";
+if (handleCliVersionFlag(process.argv.slice(2), import.meta.url, "kynver-mcp-estimator")) {
+    // exits
+}
 const server = createEstimatorServer();
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/dist/lib/package-version.d.ts

@@ -0,0 +1,7 @@
+/** Read a field from the nearest `package.json` above this module. */
+export declare function readOwnPackageJsonField(moduleUrl: string, field: "version" | "name"): string;
+export declare function readOwnPackageVersion(moduleUrl?: string): string;
+export declare function wantsCliVersion(argv: string[]): boolean;
+export declare function printCliVersionAndExit(version: string, binName?: string): never;
+/** When `--version` / `-v` is present, print package version and exit before side effects. */
+export declare function handleCliVersionFlag(argv: string[], moduleUrl?: string, binName?: string): boolean;

package/dist/lib/package-version.js

@@ -0,0 +1,44 @@
+// @generated — synced from packages/kynver-mcp-sse-lib/src/package-version.ts via scripts/sync-mcp-sse-server.mjs
+// Do not edit by hand; change the canonical file and re-run the sync script.
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function resolvePackageRoot(moduleUrl) {
+    let dir = dirname(fileURLToPath(moduleUrl));
+    for (let depth = 0; depth < 6; depth += 1) {
+        if (existsSync(join(dir, "package.json")))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new Error(`package.json not found above ${dirname(fileURLToPath(moduleUrl))}`);
+}
+/** Read a field from the nearest `package.json` above this module. */
+export function readOwnPackageJsonField(moduleUrl, field) {
+    const pkgPath = join(resolvePackageRoot(moduleUrl), "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    const value = pkg[field];
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`Missing package.json ${field} at ${pkgPath}`);
+    }
+    return value;
+}
+export function readOwnPackageVersion(moduleUrl = import.meta.url) {
+    return readOwnPackageJsonField(moduleUrl, "version");
+}
+export function wantsCliVersion(argv) {
+    return argv.some((arg) => arg === "--version" || arg === "-v");
+}
+export function printCliVersionAndExit(version, binName) {
+    console.log(binName ? `${binName} ${version}` : version);
+    process.exit(0);
+}
+/** When `--version` / `-v` is present, print package version and exit before side effects. */
+export function handleCliVersionFlag(argv, moduleUrl = import.meta.url, binName) {
+    if (!wantsCliVersion(argv))
+        return false;
+    printCliVersionAndExit(readOwnPackageVersion(moduleUrl), binName);
+    return true;
+}

package/dist/server.js

@@ -12,16 +12,19 @@ import * as statsPdfTools from "./tools/stats-pdf-tools.js";
 import * as visionTools from "./tools/vision-tools.js";
 import * as companyTools from "./tools/company-tools.js";
 import * as clientTools from "./tools/client-tools.js";
+import * as takeoffTools from "./tools/takeoff-tools.js";
+import { readOwnPackageVersion } from "./lib/package-version.js";
+const PACKAGE_VERSION = readOwnPackageVersion(import.meta.url);
 function toolResult(text) {
     return { content: [{ type: "text", text }] };
 }
 export function createEstimatorServer() {
-    const server = new McpServer({ name: "kynver-mcp-estimator", version: "0.1.0" }, { capabilities: { tools: {} } });
+    const server = new McpServer({ name: "kynver-mcp-estimator", version: PACKAGE_VERSION }, { capabilities: { tools: {} } });
     function register(name, config, run) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         server.registerTool(name, config, async (args) => toolResult(await run(args)));
     }
-    // --- Catalog tools (8) ---
+    // --- Catalog tools (9) ---
     register(catalogTools.importCatalog.name, { description: catalogTools.importCatalog.description, inputSchema: catalogTools.importCatalog.inputSchemaZod }, (args) => catalogTools.importCatalog.execute(args));
     register(catalogTools.reviewImport.name, { description: catalogTools.reviewImport.description, inputSchema: catalogTools.reviewImport.inputSchemaZod }, (args) => catalogTools.reviewImport.execute(args));
     register(catalogTools.commitImport.name, { description: catalogTools.commitImport.description, inputSchema: catalogTools.commitImport.inputSchemaZod }, (args) => catalogTools.commitImport.execute(args));
@@ -74,5 +77,22 @@ export function createEstimatorServer() {
     register(clientTools.getClient.name, { description: clientTools.getClient.description, inputSchema: clientTools.getClient.inputSchemaZod }, (args) => clientTools.getClient.execute(args));
     register(clientTools.updateClient.name, { description: clientTools.updateClient.description, inputSchema: clientTools.updateClient.inputSchemaZod }, (args) => clientTools.updateClient.execute(args));
     register(clientTools.deleteClient.name, { description: clientTools.deleteClient.description, inputSchema: clientTools.deleteClient.inputSchemaZod }, (args) => clientTools.deleteClient.execute(args));
+    // --- Takeoff / approval tools (16) ---
+    register(takeoffTools.createTakeoffProject.name, { description: takeoffTools.createTakeoffProject.description, inputSchema: takeoffTools.createTakeoffProject.inputSchemaZod }, (args) => takeoffTools.createTakeoffProject.execute(args));
+    register(takeoffTools.getTakeoffProject.name, { description: takeoffTools.getTakeoffProject.description, inputSchema: takeoffTools.getTakeoffProject.inputSchemaZod }, (args) => takeoffTools.getTakeoffProject.execute(args));
+    register(takeoffTools.listTakeoffProjects.name, { description: takeoffTools.listTakeoffProjects.description, inputSchema: takeoffTools.listTakeoffProjects.inputSchemaZod }, (args) => takeoffTools.listTakeoffProjects.execute(args));
+    register(takeoffTools.uploadTakeoffInput.name, { description: takeoffTools.uploadTakeoffInput.description, inputSchema: takeoffTools.uploadTakeoffInput.inputSchemaZod }, (args) => takeoffTools.uploadTakeoffInput.execute(args));
+    register(takeoffTools.runTakeoffExtract.name, { description: takeoffTools.runTakeoffExtract.description, inputSchema: takeoffTools.runTakeoffExtract.inputSchemaZod }, (args) => takeoffTools.runTakeoffExtract.execute(args));
+    register(takeoffTools.listTakeoffRows.name, { description: takeoffTools.listTakeoffRows.description, inputSchema: takeoffTools.listTakeoffRows.inputSchemaZod }, (args) => takeoffTools.listTakeoffRows.execute(args));
+    register(takeoffTools.reviewTakeoffRow.name, { description: takeoffTools.reviewTakeoffRow.description, inputSchema: takeoffTools.reviewTakeoffRow.inputSchemaZod }, (args) => takeoffTools.reviewTakeoffRow.execute(args));
+    register(takeoffTools.commitTakeoff.name, { description: takeoffTools.commitTakeoff.description, inputSchema: takeoffTools.commitTakeoff.inputSchemaZod }, (args) => takeoffTools.commitTakeoff.execute(args));
+    register(takeoffTools.listSystemPacks.name, { description: takeoffTools.listSystemPacks.description, inputSchema: takeoffTools.listSystemPacks.inputSchemaZod }, (args) => takeoffTools.listSystemPacks.execute(args));
+    register(takeoffTools.applySystemPack.name, { description: takeoffTools.applySystemPack.description, inputSchema: takeoffTools.applySystemPack.inputSchemaZod }, (args) => takeoffTools.applySystemPack.execute(args));
+    register(takeoffTools.listServiceProfiles.name, { description: takeoffTools.listServiceProfiles.description, inputSchema: takeoffTools.listServiceProfiles.inputSchemaZod }, (args) => takeoffTools.listServiceProfiles.execute(args));
+    register(takeoffTools.upsertServiceProfile.name, { description: takeoffTools.upsertServiceProfile.description, inputSchema: takeoffTools.upsertServiceProfile.inputSchemaZod }, (args) => takeoffTools.upsertServiceProfile.execute(args));
+    register(takeoffTools.generateEstimateFromTakeoff.name, { description: takeoffTools.generateEstimateFromTakeoff.description, inputSchema: takeoffTools.generateEstimateFromTakeoff.inputSchemaZod }, (args) => takeoffTools.generateEstimateFromTakeoff.execute(args));
+    register(takeoffTools.requestEstimateApproval.name, { description: takeoffTools.requestEstimateApproval.description, inputSchema: takeoffTools.requestEstimateApproval.inputSchemaZod }, (args) => takeoffTools.requestEstimateApproval.execute(args));
+    register(takeoffTools.approveEstimate.name, { description: takeoffTools.approveEstimate.description, inputSchema: takeoffTools.approveEstimate.inputSchemaZod }, (args) => takeoffTools.approveEstimate.execute(args));
+    register(takeoffTools.getEstimateApproval.name, { description: takeoffTools.getEstimateApproval.description, inputSchema: takeoffTools.getEstimateApproval.inputSchemaZod }, (args) => takeoffTools.getEstimateApproval.execute(args));
     return server;
 }

package/dist/tools/client-tools.d.ts

@@ -60,15 +60,15 @@ declare const listClientsSchema: z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
     cursor: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
+    search?: string | undefined;
     limit?: number | undefined;
     cursor?: string | undefined;
     companyId?: string | undefined;
-    search?: string | undefined;
 }, {
+    search?: string | undefined;
     limit?: number | undefined;
     cursor?: string | undefined;
     companyId?: string | undefined;
-    search?: string | undefined;
 }>;
 export declare const listClients: {
     name: string;
@@ -79,15 +79,15 @@ export declare const listClients: {
         limit: z.ZodOptional<z.ZodNumber>;
         cursor: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
+        search?: string | undefined;
         limit?: number | undefined;
         cursor?: string | undefined;
         companyId?: string | undefined;
-        search?: string | undefined;
     }, {
+        search?: string | undefined;
         limit?: number | undefined;
         cursor?: string | undefined;
         companyId?: string | undefined;
-        search?: string | undefined;
     }>;
     execute: (args: z.infer<typeof listClientsSchema>) => Promise<string>;
 };

package/dist/tools/company-tools.d.ts

@@ -47,13 +47,13 @@ declare const listCompaniesSchema: z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
     cursor: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
+    search?: string | undefined;
     limit?: number | undefined;
     cursor?: string | undefined;
-    search?: string | undefined;
 }, {
+    search?: string | undefined;
     limit?: number | undefined;
     cursor?: string | undefined;
-    search?: string | undefined;
 }>;
 export declare const listCompanies: {
     name: string;
@@ -63,13 +63,13 @@ export declare const listCompanies: {
         limit: z.ZodOptional<z.ZodNumber>;
         cursor: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
+        search?: string | undefined;
         limit?: number | undefined;
         cursor?: string | undefined;
-        search?: string | undefined;
     }, {
+        search?: string | undefined;
         limit?: number | undefined;
         cursor?: string | undefined;
-        search?: string | undefined;
     }>;
     execute: (args: z.infer<typeof listCompaniesSchema>) => Promise<string>;
 };

package/dist/tools/takeoff-tools.d.ts

@@ -0,0 +1,456 @@
+import { z } from "zod";
+declare const projectIdSchema: z.ZodObject<{
+    projectId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    projectId: string;
+}, {
+    projectId: string;
+}>;
+declare const createTakeoffProjectSchema: z.ZodObject<{
+    projectName: z.ZodString;
+    buildingType: z.ZodEnum<["commercial", "residential"]>;
+    siteAddress: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodOptional<z.ZodString>;
+    companyId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    projectName: string;
+    buildingType: "commercial" | "residential";
+    clientId?: string | undefined;
+    companyId?: string | undefined;
+    siteAddress?: string | undefined;
+}, {
+    projectName: string;
+    buildingType: "commercial" | "residential";
+    clientId?: string | undefined;
+    companyId?: string | undefined;
+    siteAddress?: string | undefined;
+}>;
+declare const listTakeoffProjectsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+declare const uploadTakeoffInputSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    kind: z.ZodString;
+    fileName: z.ZodString;
+    base64: z.ZodString;
+    mimeType: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    base64: string;
+    projectId: string;
+    kind: string;
+    fileName: string;
+    mimeType?: string | undefined;
+}, {
+    base64: string;
+    projectId: string;
+    kind: string;
+    fileName: string;
+    mimeType?: string | undefined;
+}>;
+declare const listTakeoffRowsSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    reviewState: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    projectId: string;
+    reviewState?: string | undefined;
+}, {
+    projectId: string;
+    reviewState?: string | undefined;
+}>;
+declare const reviewTakeoffRowSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    rowId: z.ZodString;
+    action: z.ZodEnum<["approve", "skip", "edit"]>;
+    edits: z.ZodOptional<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        quantity: z.ZodOptional<z.ZodNumber>;
+        unit: z.ZodOptional<z.ZodString>;
+        serviceCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        serviceCode?: string | null | undefined;
+        unit?: string | undefined;
+        quantity?: number | undefined;
+        description?: string | undefined;
+    }, {
+        serviceCode?: string | null | undefined;
+        unit?: string | undefined;
+        quantity?: number | undefined;
+        description?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    action: "skip" | "edit" | "approve";
+    projectId: string;
+    rowId: string;
+    edits?: {
+        serviceCode?: string | null | undefined;
+        unit?: string | undefined;
+        quantity?: number | undefined;
+        description?: string | undefined;
+    } | undefined;
+}, {
+    action: "skip" | "edit" | "approve";
+    projectId: string;
+    rowId: string;
+    edits?: {
+        serviceCode?: string | null | undefined;
+        unit?: string | undefined;
+        quantity?: number | undefined;
+        description?: string | undefined;
+    } | undefined;
+}>;
+declare const commitTakeoffSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    overrideNote: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    projectId: string;
+    overrideNote?: string | undefined;
+}, {
+    projectId: string;
+    overrideNote?: string | undefined;
+}>;
+declare const listSystemPacksSchema: z.ZodObject<{
+    segment: z.ZodOptional<z.ZodEnum<["commercial", "residential"]>>;
+}, "strip", z.ZodTypeAny, {
+    segment?: "commercial" | "residential" | undefined;
+}, {
+    segment?: "commercial" | "residential" | undefined;
+}>;
+declare const applySystemPackSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    systemPackSlug: z.ZodString;
+    serviceProfileId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    projectId: string;
+    systemPackSlug: string;
+    serviceProfileId?: string | undefined;
+}, {
+    projectId: string;
+    systemPackSlug: string;
+    serviceProfileId?: string | undefined;
+}>;
+declare const listServiceProfilesSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+declare const upsertServiceProfileSchema: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodString;
+    segment: z.ZodEnum<["commercial_service", "commercial_production", "residential_service", "residential_production"]>;
+    laborMultiplier: z.ZodOptional<z.ZodNumber>;
+    defaultWastePercent: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    segment: "commercial_service" | "commercial_production" | "residential_service" | "residential_production";
+    slug: string;
+    laborMultiplier?: number | undefined;
+    defaultWastePercent?: number | undefined;
+}, {
+    name: string;
+    segment: "commercial_service" | "commercial_production" | "residential_service" | "residential_production";
+    slug: string;
+    laborMultiplier?: number | undefined;
+    defaultWastePercent?: number | undefined;
+}>;
+declare const requestEstimateApprovalSchema: z.ZodObject<{
+    estimateId: z.ZodString;
+    note: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    estimateId: string;
+    note?: string | undefined;
+}, {
+    estimateId: string;
+    note?: string | undefined;
+}>;
+declare const approveEstimateSchema: z.ZodObject<{
+    estimateId: z.ZodString;
+    approvalId: z.ZodString;
+    action: z.ZodEnum<["approve", "reject"]>;
+    note: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    action: "approve" | "reject";
+    estimateId: string;
+    approvalId: string;
+    note?: string | undefined;
+}, {
+    action: "approve" | "reject";
+    estimateId: string;
+    approvalId: string;
+    note?: string | undefined;
+}>;
+declare const getEstimateApprovalSchema: z.ZodObject<{
+    estimateId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    estimateId: string;
+}, {
+    estimateId: string;
+}>;
+export declare const createTakeoffProject: {
+    name: string;
+    description: string;
+    inputSchemaZod: z.ZodObject<{
+        projectName: z.ZodString;
+        buildingType: z.ZodEnum<["commercial", "residential"]>;
+        siteAddress: z.ZodOptional<z.ZodString>;
+        clientId: z.ZodOptional<z.ZodString>;
+        companyId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        projectName: string;
+        buildingType: "commercial" | "residential";
+        clientId?: string | undefined;
+        companyId?: string | undefined;
+        siteAddress?: string | undefined;
+    }, {
+        projectName: string;
+        buildingType: "commercial" | "residential";
+        clientId?: string | undefined;
+        companyId?: string | undefined;
+        siteAddress?: string | undefined;
+    }>;
+    execute: (args: z.infer<typeof createTakeoffProjectSchema>) => Promise<string>;
+};
+export declare const getTakeoffProject: {
+    name: string;
+    description: string;
+    inputSchemaZod: z.ZodObject<{
+        projectId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        projectId: string;
+    }, {
+        projectId: string;
+    }>;
+    execute: (args: z.infer<typeof projectIdSchema>) => Promise<string>;
+};
+export declare const listTakeoffProjects: {
+    name: string;
+    description: string;
+    inputSchemaZod: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    execute: (_args: z.infer<typeof listTakeoffProjectsSchema>) => Promise<string>;
+};
+export declare const uploadTakeoffInput: {
+    name: string;
+    description: string;
+    inputSchemaZod: z.ZodObject<{
+        projectId: z.ZodString;
+        kind: z.ZodString;
+        fileName: z.ZodString;
+        base64: z.ZodString;
+        mimeType: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        base64: string;
+        projectId: string;
+        kind: string;
+        fileName: string;
+        mimeType?: string | undefined;
+    }, {
+        base64: string;
+        projectId: string;
+        kind: string;
+        fileName: string;
+        mimeType?: string | undefined;
+    }>;
+    execute: (args: z.infer<typeof uploadTakeoffInputSchema>) => Promise<string>;
+};
+export declare const runTakeoffExtract: {
+    name: string;
+    description: string;
+    inputSchemaZod: z.ZodObject<{
+        projectId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        projectId: string;
+    }, {
+        projectId: string;
+    }>;
+    execute: (args: z.infer<typeof projectIdSchema>) => Promise<string>;
+};
+export declare const listTakeoffRows: {
+    name: string;
+    description: string;
+    inputSchemaZod: z.ZodObject<{
+        projectId: z.ZodString;
+        reviewState: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        projectId: string;
+        reviewState?: string | undefined;
+    }, {
+        projectId: string;
+        reviewState?: string | undefined;
+    }>;
+    execute: (args: z.infer<typeof listTakeoffRowsSchema>) => Promise<string>;
+};
+export declare const reviewTakeoffRow: {
+    name: string;
+    description: string;
+    inputSchemaZod: z.ZodObject<{
+        projectId: z.ZodString;
+        rowId: z.ZodString;
+        action: z.ZodEnum<["approve", "skip", "edit"]>;
+        edits: z.ZodOptional<z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            quantity: z.ZodOptional<z.ZodNumber>;
+            unit: z.ZodOptional<z.ZodString>;
+            serviceCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            serviceCode?: string | null | undefined;
+            unit?: string | undefined;
+            quantity?: number | undefined;
+            description?: string | undefined;
+        }, {
+            serviceCode?: string | null | undefined;
+            unit?: string | undefined;
+            quantity?: number | undefined;
+            description?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        action: "skip" | "edit" | "approve";
+        projectId: string;
+        rowId: string;
+        edits?: {
+            serviceCode?: string | null | undefined;
+            unit?: string | undefined;
+            quantity?: number | undefined;
+            description?: string | undefined;
+        } | undefined;
+    }, {
+        action: "skip" | "edit" | "approve";
+        projectId: string;
+        rowId: string;
+        edits?: {
+            serviceCode?: string | null | undefined;
+            unit?: string | undefined;
+            quantity?: number | undefined;
+            description?: string | undefined;
+        } | undefined;
+    }>;
+    execute: (args: z.infer<typeof reviewTakeoffRowSchema>) => Promise<string>;
+};
+export declare const commitTakeoff: {
+    name: string;
+    description: string;
+    inputSchemaZod: z.ZodObject<{
+        projectId: z.ZodString;
+        overrideNote: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        projectId: string;
+        overrideNote?: string | undefined;
+    }, {
+        projectId: string;
+        overrideNote?: string | undefined;
+    }>;
+    execute: (args: z.infer<typeof commitTakeoffSchema>) => Promise<string>;
+};
+export declare const listSystemPacks: {
+    name: string;
+    description: string;
+    inputSchemaZod: z.ZodObject<{
+        segment: z.ZodOptional<z.ZodEnum<["commercial", "residential"]>>;
+    }, "strip", z.ZodTypeAny, {
+        segment?: "commercial" | "residential" | undefined;
+    }, {
+        segment?: "commercial" | "residential" | undefined;
+    }>;
+    execute: (args: z.infer<typeof listSystemPacksSchema>) => Promise<string>;
+};
+export declare const applySystemPack: {
+    name: string;
+    description: string;
+    inputSchemaZod: z.ZodObject<{
+        projectId: z.ZodString;
+        systemPackSlug: z.ZodString;
+        serviceProfileId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        projectId: string;
+        systemPackSlug: string;
+        serviceProfileId?: string | undefined;
+    }, {
+        projectId: string;
+        systemPackSlug: string;
+        serviceProfileId?: string | undefined;
+    }>;
+    execute: (args: z.infer<typeof applySystemPackSchema>) => Promise<string>;
+};
+export declare const listServiceProfiles: {
+    name: string;
+    description: string;
+    inputSchemaZod: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    execute: (_args: z.infer<typeof listServiceProfilesSchema>) => Promise<string>;
+};
+export declare const upsertServiceProfile: {
+    name: string;
+    description: string;
+    inputSchemaZod: z.ZodObject<{
+        slug: z.ZodString;
+        name: z.ZodString;
+        segment: z.ZodEnum<["commercial_service", "commercial_production", "residential_service", "residential_production"]>;
+        laborMultiplier: z.ZodOptional<z.ZodNumber>;
+        defaultWastePercent: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        segment: "commercial_service" | "commercial_production" | "residential_service" | "residential_production";
+        slug: string;
+        laborMultiplier?: number | undefined;
+        defaultWastePercent?: number | undefined;
+    }, {
+        name: string;
+        segment: "commercial_service" | "commercial_production" | "residential_service" | "residential_production";
+        slug: string;
+        laborMultiplier?: number | undefined;
+        defaultWastePercent?: number | undefined;
+    }>;
+    execute: (args: z.infer<typeof upsertServiceProfileSchema>) => Promise<string>;
+};
+export declare const generateEstimateFromTakeoff: {
+    name: string;
+    description: string;
+    inputSchemaZod: z.ZodObject<{
+        projectId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        projectId: string;
+    }, {
+        projectId: string;
+    }>;
+    execute: (args: z.infer<typeof projectIdSchema>) => Promise<string>;
+};
+export declare const requestEstimateApproval: {
+    name: string;
+    description: string;
+    inputSchemaZod: z.ZodObject<{
+        estimateId: z.ZodString;
+        note: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        estimateId: string;
+        note?: string | undefined;
+    }, {
+        estimateId: string;
+        note?: string | undefined;
+    }>;
+    execute: (args: z.infer<typeof requestEstimateApprovalSchema>) => Promise<string>;
+};
+export declare const approveEstimate: {
+    name: string;
+    description: string;
+    inputSchemaZod: z.ZodObject<{
+        estimateId: z.ZodString;
+        approvalId: z.ZodString;
+        action: z.ZodEnum<["approve", "reject"]>;
+        note: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        action: "approve" | "reject";
+        estimateId: string;
+        approvalId: string;
+        note?: string | undefined;
+    }, {
+        action: "approve" | "reject";
+        estimateId: string;
+        approvalId: string;
+        note?: string | undefined;
+    }>;
+    execute: (args: z.infer<typeof approveEstimateSchema>) => Promise<string>;
+};
+export declare const getEstimateApproval: {
+    name: string;
+    description: string;
+    inputSchemaZod: z.ZodObject<{
+        estimateId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        estimateId: string;
+    }, {
+        estimateId: string;
+    }>;
+    execute: (args: z.infer<typeof getEstimateApprovalSchema>) => Promise<string>;
+};
+export {};

package/dist/tools/takeoff-tools.js

@@ -0,0 +1,263 @@
+import { z } from "zod";
+import * as client from "../lib/kynver-client.js";
+const projectIdSchema = z.object({ projectId: z.string().uuid() });
+const createTakeoffProjectSchema = z.object({
+    projectName: z.string(),
+    buildingType: z.enum(["commercial", "residential"]),
+    siteAddress: z.string().optional(),
+    clientId: z.string().optional(),
+    companyId: z.string().optional(),
+});
+const listTakeoffProjectsSchema = z.object({});
+const uploadTakeoffInputSchema = z.object({
+    projectId: z.string().uuid(),
+    kind: z.string(),
+    fileName: z.string(),
+    base64: z.string(),
+    mimeType: z.string().optional(),
+});
+const listTakeoffRowsSchema = z.object({
+    projectId: z.string().uuid(),
+    reviewState: z.string().optional(),
+});
+const reviewTakeoffRowSchema = z.object({
+    projectId: z.string().uuid(),
+    rowId: z.string().uuid(),
+    action: z.enum(["approve", "skip", "edit"]),
+    edits: z
+        .object({
+        description: z.string().optional(),
+        quantity: z.number().optional(),
+        unit: z.string().optional(),
+        serviceCode: z.string().nullable().optional(),
+    })
+        .optional(),
+});
+const commitTakeoffSchema = z.object({
+    projectId: z.string().uuid(),
+    overrideNote: z.string().optional(),
+});
+const listSystemPacksSchema = z.object({ segment: z.enum(["commercial", "residential"]).optional() });
+const applySystemPackSchema = z.object({
+    projectId: z.string().uuid(),
+    systemPackSlug: z.string(),
+    serviceProfileId: z.string().optional(),
+});
+const listServiceProfilesSchema = z.object({});
+const upsertServiceProfileSchema = z.object({
+    slug: z.string(),
+    name: z.string(),
+    segment: z.enum([
+        "commercial_service",
+        "commercial_production",
+        "residential_service",
+        "residential_production",
+    ]),
+    laborMultiplier: z.number().optional(),
+    defaultWastePercent: z.number().optional(),
+});
+const requestEstimateApprovalSchema = z.object({
+    estimateId: z.string().uuid(),
+    note: z.string().optional(),
+});
+const approveEstimateSchema = z.object({
+    estimateId: z.string().uuid(),
+    approvalId: z.string().uuid(),
+    action: z.enum(["approve", "reject"]),
+    note: z.string().optional(),
+});
+const getEstimateApprovalSchema = z.object({ estimateId: z.string().uuid() });
+export const createTakeoffProject = {
+    name: "estimator_create_takeoff_project",
+    description: "Create a takeoff project shell (commercial or residential). Upload inputs, run extract, review rows, commit, apply system pack, then generate estimate.",
+    inputSchemaZod: createTakeoffProjectSchema,
+    execute: async (args) => {
+        if (!client.hasApiKey())
+            return client.noApiKeyMessage();
+        const data = await client.post("/estimator/takeoffs", args);
+        return JSON.stringify(data);
+    },
+};
+export const getTakeoffProject = {
+    name: "estimator_get_takeoff_project",
+    description: "Get takeoff project with inputs, rows, status, pack/profile, linked estimate.",
+    inputSchemaZod: projectIdSchema,
+    execute: async (args) => {
+        if (!client.hasApiKey())
+            return client.noApiKeyMessage();
+        const data = await client.get(`/estimator/takeoffs/${args.projectId}`);
+        return JSON.stringify(data);
+    },
+};
+export const listTakeoffProjects = {
+    name: "estimator_list_takeoff_projects",
+    description: "List takeoff projects for the workspace.",
+    inputSchemaZod: listTakeoffProjectsSchema,
+    execute: async (_args) => {
+        if (!client.hasApiKey())
+            return client.noApiKeyMessage();
+        const data = await client.get("/estimator/takeoffs");
+        return JSON.stringify(data);
+    },
+};
+export const uploadTakeoffInput = {
+    name: "estimator_upload_takeoff_input",
+    description: "Register a takeoff file upload. Pass base64 file content via the API route from your client, or use the web UI multipart upload at POST /api/estimator/takeoffs/{id}/inputs with kind + file.",
+    inputSchemaZod: uploadTakeoffInputSchema,
+    execute: async (args) => {
+        if (!client.hasApiKey())
+            return client.noApiKeyMessage();
+        return JSON.stringify({
+            message: "Use POST /api/estimator/takeoffs/{projectId}/inputs multipart (kind + file) from an authenticated client. MCP base64 upload route can be added when hosted file relay is available.",
+            projectId: args.projectId,
+            kind: args.kind,
+            fileName: args.fileName,
+        });
+    },
+};
+export const runTakeoffExtract = {
+    name: "estimator_run_takeoff_extract",
+    description: "Run takeoff extractors on all uploaded inputs (idempotent).",
+    inputSchemaZod: projectIdSchema,
+    execute: async (args) => {
+        if (!client.hasApiKey())
+            return client.noApiKeyMessage();
+        const data = await client.post(`/estimator/takeoffs/${args.projectId}/extract`, {});
+        return JSON.stringify(data);
+    },
+};
+export const listTakeoffRows = {
+    name: "estimator_list_takeoff_rows",
+    description: "List takeoff rows with evidence and review state.",
+    inputSchemaZod: listTakeoffRowsSchema,
+    execute: async (args) => {
+        if (!client.hasApiKey())
+            return client.noApiKeyMessage();
+        const qs = args.reviewState ? `?reviewState=${args.reviewState}` : "";
+        const data = await client.get(`/estimator/takeoffs/${args.projectId}/rows${qs}`);
+        return JSON.stringify(data);
+    },
+};
+export const reviewTakeoffRow = {
+    name: "estimator_review_takeoff_row",
+    description: "Approve, skip, or edit a single takeoff row.",
+    inputSchemaZod: reviewTakeoffRowSchema,
+    execute: async (args) => {
+        if (!client.hasApiKey())
+            return client.noApiKeyMessage();
+        const { projectId, rowId, ...body } = args;
+        const data = await client.patch(`/estimator/takeoffs/${projectId}/rows/${rowId}`, body);
+        return JSON.stringify(data);
+    },
+};
+export const commitTakeoff = {
+    name: "estimator_commit_takeoff",
+    description: "Mark takeoff ready after all rows reviewed and area measurement approved (or override note).",
+    inputSchemaZod: commitTakeoffSchema,
+    execute: async (args) => {
+        if (!client.hasApiKey())
+            return client.noApiKeyMessage();
+        const data = await client.post(`/estimator/takeoffs/${args.projectId}/commit`, {
+            overrideNote: args.overrideNote,
+        });
+        return JSON.stringify(data);
+    },
+};
+export const listSystemPacks = {
+    name: "estimator_list_system_packs",
+    description: "List built-in commercial and residential system packs.",
+    inputSchemaZod: listSystemPacksSchema,
+    execute: async (args) => {
+        if (!client.hasApiKey())
+            return client.noApiKeyMessage();
+        const qs = args.segment ? `?segment=${args.segment}` : "";
+        const data = await client.get(`/estimator/system-packs${qs}`);
+        return JSON.stringify(data);
+    },
+};
+export const applySystemPack = {
+    name: "estimator_apply_system_pack",
+    description: "Set system pack slug and optional service profile on takeoff project.",
+    inputSchemaZod: applySystemPackSchema,
+    execute: async (args) => {
+        if (!client.hasApiKey())
+            return client.noApiKeyMessage();
+        const data = await client.patch(`/estimator/takeoffs/${args.projectId}`, {
+            systemPackSlug: args.systemPackSlug,
+            serviceProfileId: args.serviceProfileId ?? null,
+        });
+        return JSON.stringify(data);
+    },
+};
+export const listServiceProfiles = {
+    name: "estimator_list_service_profiles",
+    description: "List service department profiles (includes v6 defaults).",
+    inputSchemaZod: listServiceProfilesSchema,
+    execute: async (_args) => {
+        if (!client.hasApiKey())
+            return client.noApiKeyMessage();
+        const data = await client.get("/estimator/service-profiles");
+        return JSON.stringify(data);
+    },
+};
+export const upsertServiceProfile = {
+    name: "estimator_upsert_service_profile",
+    description: "Create or update a service department profile.",
+    inputSchemaZod: upsertServiceProfileSchema,
+    execute: async (args) => {
+        if (!client.hasApiKey())
+            return client.noApiKeyMessage();
+        const data = await client.post("/estimator/service-profiles", args);
+        return JSON.stringify(data);
+    },
+};
+export const generateEstimateFromTakeoff = {
+    name: "estimator_generate_estimate_from_takeoff",
+    description: "Generate draft estimate from committed takeoff + system pack. Preflight fails if catalog codes missing.",
+    inputSchemaZod: projectIdSchema,
+    execute: async (args) => {
+        if (!client.hasApiKey())
+            return client.noApiKeyMessage();
+        const data = await client.post(`/estimator/takeoffs/${args.projectId}/generate-estimate`, {});
+        return JSON.stringify(data);
+    },
+};
+export const requestEstimateApproval = {
+    name: "estimator_request_estimate_approval",
+    description: "Request owner approval before customer send.",
+    inputSchemaZod: requestEstimateApprovalSchema,
+    execute: async (args) => {
+        if (!client.hasApiKey())
+            return client.noApiKeyMessage();
+        const data = await client.post(`/estimator/estimates/${args.estimateId}/approval`, {
+            note: args.note,
+        });
+        return JSON.stringify(data);
+    },
+};
+export const approveEstimate = {
+    name: "estimator_approve_estimate",
+    description: "Approve or reject estimate (workspace owner).",
+    inputSchemaZod: approveEstimateSchema,
+    execute: async (args) => {
+        if (!client.hasApiKey())
+            return client.noApiKeyMessage();
+        const data = await client.post(`/estimator/estimates/${args.estimateId}/approval`, {
+            approvalId: args.approvalId,
+            action: args.action,
+            note: args.note,
+        });
+        return JSON.stringify(data);
+    },
+};
+export const getEstimateApproval = {
+    name: "estimator_get_estimate_approval",
+    description: "Get latest approval status for an estimate.",
+    inputSchemaZod: getEstimateApprovalSchema,
+    execute: async (args) => {
+        if (!client.hasApiKey())
+            return client.noApiKeyMessage();
+        const data = await client.get(`/estimator/estimates/${args.estimateId}/approval`);
+        return JSON.stringify(data);
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kynver-app/mcp-estimator",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Kynver Estimator MCP server — chat, estimate, and catalog tools",
   "type": "module",
   "bin": {

package/src/index.ts

@@ -1,13 +1,18 @@
-#!/usr/bin/env node
-/**
- * Kynver Estimator MCP server — stdio entry point.
- * Run: node dist/index.js
- * Env: KYNVER_API_URL (default https://kynver.com), KYNVER_API_KEY (required for all tools)
- */
-
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { createEstimatorServer } from "./server.js";
-
-const server = createEstimatorServer();
-const transport = new StdioServerTransport();
-await server.connect(transport);
+#!/usr/bin/env node
+/**
+ * Kynver Estimator MCP server — stdio entry point.
+ * Run: node dist/index.js
+ * Env: KYNVER_API_URL (default https://kynver.com), KYNVER_API_KEY (required for all tools)
+ */
+
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { handleCliVersionFlag } from "./lib/package-version.js";
+import { createEstimatorServer } from "./server.js";
+
+if (handleCliVersionFlag(process.argv.slice(2), import.meta.url, "kynver-mcp-estimator")) {
+  // exits
+}
+
+const server = createEstimatorServer();
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/src/lib/mcp-sse-server.ts

@@ -1,6 +1,6 @@
-// @generated — synced from packages/kynver-mcp-sse-lib/src/index.ts via scripts/sync-mcp-sse-server.mjs
-// Do not edit by hand; change the canonical file and re-run the sync script.
-
+// @generated — synced from packages/kynver-mcp-sse-lib/src/index.ts via scripts/sync-mcp-sse-server.mjs
+// Do not edit by hand; change the canonical file and re-run the sync script.
+
 import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
 import { timingSafeEqual } from "node:crypto";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";

package/src/lib/package-version.ts

@@ -0,0 +1,55 @@
+// @generated — synced from packages/kynver-mcp-sse-lib/src/package-version.ts via scripts/sync-mcp-sse-server.mjs
+// Do not edit by hand; change the canonical file and re-run the sync script.
+
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+function resolvePackageRoot(moduleUrl: string): string {
+  let dir = dirname(fileURLToPath(moduleUrl));
+  for (let depth = 0; depth < 6; depth += 1) {
+    if (existsSync(join(dir, "package.json"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error(`package.json not found above ${dirname(fileURLToPath(moduleUrl))}`);
+}
+
+/** Read a field from the nearest `package.json` above this module. */
+export function readOwnPackageJsonField(
+  moduleUrl: string,
+  field: "version" | "name",
+): string {
+  const pkgPath = join(resolvePackageRoot(moduleUrl), "package.json");
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as Record<string, unknown>;
+  const value = pkg[field];
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`Missing package.json ${field} at ${pkgPath}`);
+  }
+  return value;
+}
+
+export function readOwnPackageVersion(moduleUrl: string = import.meta.url): string {
+  return readOwnPackageJsonField(moduleUrl, "version");
+}
+
+export function wantsCliVersion(argv: string[]): boolean {
+  return argv.some((arg) => arg === "--version" || arg === "-v");
+}
+
+export function printCliVersionAndExit(version: string, binName?: string): never {
+  console.log(binName ? `${binName} ${version}` : version);
+  process.exit(0);
+}
+
+/** When `--version` / `-v` is present, print package version and exit before side effects. */
+export function handleCliVersionFlag(
+  argv: string[],
+  moduleUrl: string = import.meta.url,
+  binName?: string,
+): boolean {
+  if (!wantsCliVersion(argv)) return false;
+  printCliVersionAndExit(readOwnPackageVersion(moduleUrl), binName);
+  return true;
+}

package/src/server.ts

@@ -14,6 +14,9 @@ import * as visionTools from "./tools/vision-tools.js";
 import * as companyTools from "./tools/company-tools.js";
 import * as clientTools from "./tools/client-tools.js";
 import * as takeoffTools from "./tools/takeoff-tools.js";
+import { readOwnPackageVersion } from "./lib/package-version.js";
+
+const PACKAGE_VERSION = readOwnPackageVersion(import.meta.url);
 
 type ToolConfig = { description: string; inputSchema: unknown };
 
@@ -23,7 +26,7 @@ function toolResult(text: string) {
 
 export function createEstimatorServer(): McpServer {
   const server = new McpServer(
-    { name: "kynver-mcp-estimator", version: "0.2.0" },
+    { name: "kynver-mcp-estimator", version: PACKAGE_VERSION },
     { capabilities: { tools: {} } }
   );
 

package/src/tools/takeoff-tools.ts

@@ -3,18 +3,91 @@ import * as client from "../lib/kynver-client.js";
 
 const projectIdSchema = z.object({ projectId: z.string().uuid() });
 
+const createTakeoffProjectSchema = z.object({
+  projectName: z.string(),
+  buildingType: z.enum(["commercial", "residential"]),
+  siteAddress: z.string().optional(),
+  clientId: z.string().optional(),
+  companyId: z.string().optional(),
+});
+
+const listTakeoffProjectsSchema = z.object({});
+
+const uploadTakeoffInputSchema = z.object({
+  projectId: z.string().uuid(),
+  kind: z.string(),
+  fileName: z.string(),
+  base64: z.string(),
+  mimeType: z.string().optional(),
+});
+
+const listTakeoffRowsSchema = z.object({
+  projectId: z.string().uuid(),
+  reviewState: z.string().optional(),
+});
+
+const reviewTakeoffRowSchema = z.object({
+  projectId: z.string().uuid(),
+  rowId: z.string().uuid(),
+  action: z.enum(["approve", "skip", "edit"]),
+  edits: z
+    .object({
+      description: z.string().optional(),
+      quantity: z.number().optional(),
+      unit: z.string().optional(),
+      serviceCode: z.string().nullable().optional(),
+    })
+    .optional(),
+});
+
+const commitTakeoffSchema = z.object({
+  projectId: z.string().uuid(),
+  overrideNote: z.string().optional(),
+});
+
+const listSystemPacksSchema = z.object({ segment: z.enum(["commercial", "residential"]).optional() });
+
+const applySystemPackSchema = z.object({
+  projectId: z.string().uuid(),
+  systemPackSlug: z.string(),
+  serviceProfileId: z.string().optional(),
+});
+
+const listServiceProfilesSchema = z.object({});
+
+const upsertServiceProfileSchema = z.object({
+  slug: z.string(),
+  name: z.string(),
+  segment: z.enum([
+    "commercial_service",
+    "commercial_production",
+    "residential_service",
+    "residential_production",
+  ]),
+  laborMultiplier: z.number().optional(),
+  defaultWastePercent: z.number().optional(),
+});
+
+const requestEstimateApprovalSchema = z.object({
+  estimateId: z.string().uuid(),
+  note: z.string().optional(),
+});
+
+const approveEstimateSchema = z.object({
+  estimateId: z.string().uuid(),
+  approvalId: z.string().uuid(),
+  action: z.enum(["approve", "reject"]),
+  note: z.string().optional(),
+});
+
+const getEstimateApprovalSchema = z.object({ estimateId: z.string().uuid() });
+
 export const createTakeoffProject = {
   name: "estimator_create_takeoff_project",
   description:
     "Create a takeoff project shell (commercial or residential). Upload inputs, run extract, review rows, commit, apply system pack, then generate estimate.",
-  inputSchemaZod: z.object({
-    projectName: z.string(),
-    buildingType: z.enum(["commercial", "residential"]),
-    siteAddress: z.string().optional(),
-    clientId: z.string().optional(),
-    companyId: z.string().optional(),
-  }),
-  execute: async (args: z.infer<typeof createTakeoffProject.inputSchemaZod>): Promise<string> => {
+  inputSchemaZod: createTakeoffProjectSchema,
+  execute: async (args: z.infer<typeof createTakeoffProjectSchema>): Promise<string> => {
     if (!client.hasApiKey()) return client.noApiKeyMessage();
     const data = await client.post("/estimator/takeoffs", args);
     return JSON.stringify(data);
@@ -35,8 +108,8 @@ export const getTakeoffProject = {
 export const listTakeoffProjects = {
   name: "estimator_list_takeoff_projects",
   description: "List takeoff projects for the workspace.",
-  inputSchemaZod: z.object({}),
-  execute: async (): Promise<string> => {
+  inputSchemaZod: listTakeoffProjectsSchema,
+  execute: async (_args: z.infer<typeof listTakeoffProjectsSchema>): Promise<string> => {
     if (!client.hasApiKey()) return client.noApiKeyMessage();
     const data = await client.get("/estimator/takeoffs");
     return JSON.stringify(data);
@@ -47,14 +120,8 @@ export const uploadTakeoffInput = {
   name: "estimator_upload_takeoff_input",
   description:
     "Register a takeoff file upload. Pass base64 file content via the API route from your client, or use the web UI multipart upload at POST /api/estimator/takeoffs/{id}/inputs with kind + file.",
-  inputSchemaZod: z.object({
-    projectId: z.string().uuid(),
-    kind: z.string(),
-    fileName: z.string(),
-    base64: z.string(),
-    mimeType: z.string().optional(),
-  }),
-  execute: async (args: z.infer<typeof uploadTakeoffInput.inputSchemaZod>): Promise<string> => {
+  inputSchemaZod: uploadTakeoffInputSchema,
+  execute: async (args: z.infer<typeof uploadTakeoffInputSchema>): Promise<string> => {
     if (!client.hasApiKey()) return client.noApiKeyMessage();
     return JSON.stringify({
       message:
@@ -80,11 +147,8 @@ export const runTakeoffExtract = {
 export const listTakeoffRows = {
   name: "estimator_list_takeoff_rows",
   description: "List takeoff rows with evidence and review state.",
-  inputSchemaZod: z.object({
-    projectId: z.string().uuid(),
-    reviewState: z.string().optional(),
-  }),
-  execute: async (args: z.infer<typeof listTakeoffRows.inputSchemaZod>): Promise<string> => {
+  inputSchemaZod: listTakeoffRowsSchema,
+  execute: async (args: z.infer<typeof listTakeoffRowsSchema>): Promise<string> => {
     if (!client.hasApiKey()) return client.noApiKeyMessage();
     const qs = args.reviewState ? `?reviewState=${args.reviewState}` : "";
     const data = await client.get(`/estimator/takeoffs/${args.projectId}/rows${qs}`);
@@ -95,20 +159,8 @@ export const listTakeoffRows = {
 export const reviewTakeoffRow = {
   name: "estimator_review_takeoff_row",
   description: "Approve, skip, or edit a single takeoff row.",
-  inputSchemaZod: z.object({
-    projectId: z.string().uuid(),
-    rowId: z.string().uuid(),
-    action: z.enum(["approve", "skip", "edit"]),
-    edits: z
-      .object({
-        description: z.string().optional(),
-        quantity: z.number().optional(),
-        unit: z.string().optional(),
-        serviceCode: z.string().nullable().optional(),
-      })
-      .optional(),
-  }),
-  execute: async (args: z.infer<typeof reviewTakeoffRow.inputSchemaZod>): Promise<string> => {
+  inputSchemaZod: reviewTakeoffRowSchema,
+  execute: async (args: z.infer<typeof reviewTakeoffRowSchema>): Promise<string> => {
     if (!client.hasApiKey()) return client.noApiKeyMessage();
     const { projectId, rowId, ...body } = args;
     const data = await client.patch(`/estimator/takeoffs/${projectId}/rows/${rowId}`, body);
@@ -119,11 +171,8 @@ export const reviewTakeoffRow = {
 export const commitTakeoff = {
   name: "estimator_commit_takeoff",
   description: "Mark takeoff ready after all rows reviewed and area measurement approved (or override note).",
-  inputSchemaZod: z.object({
-    projectId: z.string().uuid(),
-    overrideNote: z.string().optional(),
-  }),
-  execute: async (args: z.infer<typeof commitTakeoff.inputSchemaZod>): Promise<string> => {
+  inputSchemaZod: commitTakeoffSchema,
+  execute: async (args: z.infer<typeof commitTakeoffSchema>): Promise<string> => {
     if (!client.hasApiKey()) return client.noApiKeyMessage();
     const data = await client.post(`/estimator/takeoffs/${args.projectId}/commit`, {
       overrideNote: args.overrideNote,
@@ -135,8 +184,8 @@ export const commitTakeoff = {
 export const listSystemPacks = {
   name: "estimator_list_system_packs",
   description: "List built-in commercial and residential system packs.",
-  inputSchemaZod: z.object({ segment: z.enum(["commercial", "residential"]).optional() }),
-  execute: async (args: z.infer<typeof listSystemPacks.inputSchemaZod>): Promise<string> => {
+  inputSchemaZod: listSystemPacksSchema,
+  execute: async (args: z.infer<typeof listSystemPacksSchema>): Promise<string> => {
     if (!client.hasApiKey()) return client.noApiKeyMessage();
     const qs = args.segment ? `?segment=${args.segment}` : "";
     const data = await client.get(`/estimator/system-packs${qs}`);
@@ -147,12 +196,8 @@ export const listSystemPacks = {
 export const applySystemPack = {
   name: "estimator_apply_system_pack",
   description: "Set system pack slug and optional service profile on takeoff project.",
-  inputSchemaZod: z.object({
-    projectId: z.string().uuid(),
-    systemPackSlug: z.string(),
-    serviceProfileId: z.string().optional(),
-  }),
-  execute: async (args: z.infer<typeof applySystemPack.inputSchemaZod>): Promise<string> => {
+  inputSchemaZod: applySystemPackSchema,
+  execute: async (args: z.infer<typeof applySystemPackSchema>): Promise<string> => {
     if (!client.hasApiKey()) return client.noApiKeyMessage();
     const data = await client.patch(`/estimator/takeoffs/${args.projectId}`, {
       systemPackSlug: args.systemPackSlug,
@@ -165,8 +210,8 @@ export const applySystemPack = {
 export const listServiceProfiles = {
   name: "estimator_list_service_profiles",
   description: "List service department profiles (includes v6 defaults).",
-  inputSchemaZod: z.object({}),
-  execute: async (): Promise<string> => {
+  inputSchemaZod: listServiceProfilesSchema,
+  execute: async (_args: z.infer<typeof listServiceProfilesSchema>): Promise<string> => {
     if (!client.hasApiKey()) return client.noApiKeyMessage();
     const data = await client.get("/estimator/service-profiles");
     return JSON.stringify(data);
@@ -176,19 +221,8 @@ export const listServiceProfiles = {
 export const upsertServiceProfile = {
   name: "estimator_upsert_service_profile",
   description: "Create or update a service department profile.",
-  inputSchemaZod: z.object({
-    slug: z.string(),
-    name: z.string(),
-    segment: z.enum([
-      "commercial_service",
-      "commercial_production",
-      "residential_service",
-      "residential_production",
-    ]),
-    laborMultiplier: z.number().optional(),
-    defaultWastePercent: z.number().optional(),
-  }),
-  execute: async (args: z.infer<typeof upsertServiceProfile.inputSchemaZod>): Promise<string> => {
+  inputSchemaZod: upsertServiceProfileSchema,
+  execute: async (args: z.infer<typeof upsertServiceProfileSchema>): Promise<string> => {
     if (!client.hasApiKey()) return client.noApiKeyMessage();
     const data = await client.post("/estimator/service-profiles", args);
     return JSON.stringify(data);
@@ -210,8 +244,8 @@ export const generateEstimateFromTakeoff = {
 export const requestEstimateApproval = {
   name: "estimator_request_estimate_approval",
   description: "Request owner approval before customer send.",
-  inputSchemaZod: z.object({ estimateId: z.string().uuid(), note: z.string().optional() }),
-  execute: async (args: z.infer<typeof requestEstimateApproval.inputSchemaZod>): Promise<string> => {
+  inputSchemaZod: requestEstimateApprovalSchema,
+  execute: async (args: z.infer<typeof requestEstimateApprovalSchema>): Promise<string> => {
     if (!client.hasApiKey()) return client.noApiKeyMessage();
     const data = await client.post(`/estimator/estimates/${args.estimateId}/approval`, {
       note: args.note,
@@ -223,13 +257,8 @@ export const requestEstimateApproval = {
 export const approveEstimate = {
   name: "estimator_approve_estimate",
   description: "Approve or reject estimate (workspace owner).",
-  inputSchemaZod: z.object({
-    estimateId: z.string().uuid(),
-    approvalId: z.string().uuid(),
-    action: z.enum(["approve", "reject"]),
-    note: z.string().optional(),
-  }),
-  execute: async (args: z.infer<typeof approveEstimate.inputSchemaZod>): Promise<string> => {
+  inputSchemaZod: approveEstimateSchema,
+  execute: async (args: z.infer<typeof approveEstimateSchema>): Promise<string> => {
     if (!client.hasApiKey()) return client.noApiKeyMessage();
     const data = await client.post(`/estimator/estimates/${args.estimateId}/approval`, {
       approvalId: args.approvalId,
@@ -243,8 +272,8 @@ export const approveEstimate = {
 export const getEstimateApproval = {
   name: "estimator_get_estimate_approval",
   description: "Get latest approval status for an estimate.",
-  inputSchemaZod: z.object({ estimateId: z.string().uuid() }),
-  execute: async (args: z.infer<typeof getEstimateApproval.inputSchemaZod>): Promise<string> => {
+  inputSchemaZod: getEstimateApprovalSchema,
+  execute: async (args: z.infer<typeof getEstimateApprovalSchema>): Promise<string> => {
     if (!client.hasApiKey()) return client.noApiKeyMessage();
     const data = await client.get(`/estimator/estimates/${args.estimateId}/approval`);
     return JSON.stringify(data);