spm-mcp 0.1.0

package/dist/src/index.js

@@ -0,0 +1,185 @@
+/**
+ * SPM MCP Server — Main entry point.
+ *
+ * Creates an MCP server with 6 stateless tools:
+ * - spm_list_nano_apps: Discover available analysis templates
+ * - spm_analyze: Expert analysis of a product document
+ * - spm_clarify: Clarification questions for identified gaps
+ * - spm_evaluate: Re-score gaps after clarification rounds
+ * - spm_improve: Generate improved content for gaps
+ * - spm_create_custom_nano_app: Create a custom nano app
+ *
+ * Used by both stdio (local NPM) and HTTP (Cloud Run) transports.
+ */
+import { z } from 'zod';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { handleListNanoApps } from './tools/list-nano-apps.js';
+import { handleAnalyze } from './tools/analyze.js';
+import { handleClarify } from './tools/clarify.js';
+import { handleEvaluate } from './tools/evaluate.js';
+import { handleImprove } from './tools/improve.js';
+import { handleCreateCustomNanoApp } from './tools/create-custom-nano-app.js';
+import { SpmApiError } from './client/spm-api.js';
+export function createSpmMcpServer(options) {
+    const server = new McpServer({
+        name: 'Super Product Manager',
+        version: '0.1.0',
+    });
+    const apiKey = options?.apiKey;
+    // Tool: spm_list_nano_apps
+    server.tool('spm_list_nano_apps', 'List all available SPM nano app templates for product document analysis. ' +
+        'Returns template keys, names, descriptions, and categories. ' +
+        'Use this to discover which analysis types are available before calling spm_analyze.', {}, async () => {
+        try {
+            const result = await handleListNanoApps(apiKey);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (err) {
+            return errorResponse(err);
+        }
+    });
+    // Tool: spm_analyze
+    server.tool('spm_analyze', 'Analyze a product document against SPM expert expectations. ' +
+        'Pass a document and a nano_app_id (e.g., "prd_critique", "user_story", "growth_strategy") ' +
+        'to get an expert analysis with expectations, sub-expectations, scores, and evidence. ' +
+        'Call spm_list_nano_apps first if you need to discover available templates.', {
+        document: z.string().describe('The product document text to analyze'),
+        nano_app_id: z.string().describe('The nano app template key (e.g., "prd_critique"). Call spm_list_nano_apps to see available options.'),
+    }, async (input) => {
+        try {
+            const result = await handleAnalyze(input, apiKey);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (err) {
+            return errorResponse(err);
+        }
+    });
+    // Tool: spm_clarify
+    server.tool('spm_clarify', 'Get clarification questions for gaps identified in an SPM analysis. ' +
+        'Pass the original document, the expert analysis context, and a target gap. ' +
+        'Returns targeted questions with suggested answers to close document gaps.', {
+        document: z.string().describe('The original product document text'),
+        nano_app_id: z.string().describe('The nano app template key used in the analysis'),
+        main_expectation: z.string().describe('The main expectation name/text from the analysis result'),
+        all_sub_expectations: z.string().describe('JSON string of all sub-expectations from the analysis. Pass the not_met_expectations array from spm_analyze result.'),
+        target_sub_expectation: z.string().describe('The specific sub-expectation (gap) to ask about. Use the title or description of the gap.'),
+        previous_answers: z.array(z.object({
+            question: z.string(),
+            answer: z.string(),
+        })).optional().describe('Array of previous Q&A pairs from this clarification session. Empty for first question.'),
+    }, async (input) => {
+        try {
+            const result = await handleClarify(input, apiKey);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (err) {
+            return errorResponse(err);
+        }
+    });
+    // Tool: spm_evaluate
+    server.tool('spm_evaluate', 'Re-score sub-expectations after clarification rounds. ' +
+        'Pass the original document, the expectations from spm_analyze, and all Q&A pairs from spm_clarify. ' +
+        'Returns updated scores showing which gaps are now covered (>=0.81) and which still need work. ' +
+        'Use after every 3 rounds of spm_clarify to measure progress.', {
+        document: z.string().describe('The original product document text'),
+        nano_app_id: z.string().describe('The nano app template key used in the analysis'),
+        main_expectation: z.string().describe('The main expectation name/text from the analysis result'),
+        all_sub_expectations: z.string().describe('JSON string of sub-expectations to evaluate. Pass the subEx array from spm_analyze.'),
+        prior_clarifications: z.array(z.object({
+            question: z.string(),
+            answer: z.string(),
+        })).describe('All Q&A pairs accumulated from spm_clarify rounds. The evaluator uses these as evidence.'),
+    }, async (input) => {
+        try {
+            const result = await handleEvaluate(input, apiKey);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (err) {
+            return errorResponse(err);
+        }
+    });
+    // Tool: spm_improve
+    server.tool('spm_improve', 'Generate improved document content for a specific gap. ' +
+        'Pass the document, the target sub-expectation, and all clarification Q&A pairs. ' +
+        'Returns paste-ready content the PM can insert into their document. ' +
+        'Use after spm_evaluate confirms the gap is sufficiently covered by clarification answers.', {
+        document: z.string().describe('The original product document text'),
+        nano_app_id: z.string().describe('The nano app template key used in the analysis'),
+        main_expectation: z.string().describe('The main expectation name/text from the analysis result'),
+        sub_expectation: z.string().describe('The specific sub-expectation/gap to generate improved content for'),
+        all_sub_expectations: z.string().optional().describe('JSON string of all sub-expectations for context. Optional but recommended.'),
+        prior_clarifications: z.array(z.object({
+            question: z.string(),
+            answer: z.string(),
+        })).describe('All Q&A pairs from clarification rounds. The improviser uses these to generate grounded content.'),
+        current_content: z.string().optional().describe('The current generated content (live_artifact) to improve upon. Empty for first generation.'),
+    }, async (input) => {
+        try {
+            const result = await handleImprove(input, apiKey);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (err) {
+            return errorResponse(err);
+        }
+    });
+    // Tool: spm_create_custom_nano_app
+    server.tool('spm_create_custom_nano_app', 'Create a custom nano app when the user\'s document doesn\'t match any existing nano app ' +
+        '(call spm_list_nano_apps first to check).\n\n' +
+        'BEFORE calling this tool, gather preferences from the user:\n' +
+        '1. WHAT TO EVALUATE → expectations + rules\n' +
+        '2. DOMAIN LENS → domainContext\n' +
+        '3. GOOD vs BAD SIGNALS → reviewer examples\n' +
+        '4. CLARIFICATION STYLE → clarification examples + instructions\n' +
+        '5. IMPROVEMENT FORMAT → improviser instructions\n\n' +
+        'IMPORTANT: Do NOT run a rigid 5-question interview. Extract what you can from the user\'s ' +
+        'initial message. Only ask 1-2 clarifying questions for what\'s genuinely missing. ' +
+        'Bias toward ACTION over interrogation. The endpoint handles missing preferences gracefully.', {
+        description: z.string().describe('What kind of document this nano app analyzes and what it should evaluate'),
+        name: z.string().optional().describe('Human-readable name for the nano app (auto-generated if omitted)'),
+        preferences: z.object({
+            domain_lens: z.string().optional().describe('Domain context and expertise lens'),
+            good_bad_signals: z.string().optional().describe('Examples of good vs bad signals for review'),
+            clarification_style: z.string().optional().describe('Style and examples for clarification questions'),
+            improvement_format: z.string().optional().describe('Format instructions for generated improvements'),
+        }).optional().describe('Optional preferences to customize the nano app behavior'),
+    }, async (input) => {
+        try {
+            const result = await handleCreateCustomNanoApp(input, apiKey);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (err) {
+            return errorResponse(err);
+        }
+    });
+    return server;
+}
+function errorResponse(err) {
+    if (err instanceof SpmApiError) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ error: err.message, code: err.code }),
+                }],
+            isError: true,
+        };
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+        content: [{ type: 'text', text: JSON.stringify({ error: message }) }],
+        isError: true,
+    };
+}
+export { SpmApiError } from './client/spm-api.js';
+//# sourceMappingURL=index.js.map

package/dist/src/stdio.d.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/**
+ * Stdio transport entry point for the SPM MCP Server.
+ *
+ * Used by Claude Code and other local MCP clients that spawn the server
+ * as a subprocess. API key is read from SPM_API_KEY env var.
+ *
+ * Configure in .claude/settings.json:
+ * {
+ *   "mcpServers": {
+ *     "spm": {
+ *       "command": "node",
+ *       "args": ["/path/to/packages/mcp-server/dist/src/stdio.js"],
+ *       "env": { "SPM_API_KEY": "spm_k_..." }
+ *     }
+ *   }
+ * }
+ */
+export {};

package/dist/src/stdio.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+/**
+ * Stdio transport entry point for the SPM MCP Server.
+ *
+ * Used by Claude Code and other local MCP clients that spawn the server
+ * as a subprocess. API key is read from SPM_API_KEY env var.
+ *
+ * Configure in .claude/settings.json:
+ * {
+ *   "mcpServers": {
+ *     "spm": {
+ *       "command": "node",
+ *       "args": ["/path/to/packages/mcp-server/dist/src/stdio.js"],
+ *       "env": { "SPM_API_KEY": "spm_k_..." }
+ *     }
+ *   }
+ * }
+ */
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createSpmMcpServer } from './index.js';
+const server = createSpmMcpServer();
+const transport = new StdioServerTransport();
+await server.connect(transport);
+//# sourceMappingURL=stdio.js.map

package/dist/src/tools/analyze.d.ts

@@ -0,0 +1,32 @@
+/**
+ * spm_analyze — Expert analysis tool.
+ *
+ * Stateless: takes a document + optional nano_app_id, calls the expert agent,
+ * returns expectations + scores + gaps. No session state needed.
+ *
+ * If nano_app_id is omitted, returns the full list of available nano apps
+ * for the user/Claude to pick from.
+ */
+export declare const analyzeDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            document: {
+                type: string;
+                description: string;
+            };
+            nano_app_id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export interface AnalyzeInput {
+    document: string;
+    nano_app_id: string;
+}
+export declare function handleAnalyze(input: AnalyzeInput, apiKey?: string): Promise<unknown>;

package/dist/src/tools/analyze.js

@@ -0,0 +1,96 @@
+/**
+ * spm_analyze — Expert analysis tool.
+ *
+ * Stateless: takes a document + optional nano_app_id, calls the expert agent,
+ * returns expectations + scores + gaps. No session state needed.
+ *
+ * If nano_app_id is omitted, returns the full list of available nano apps
+ * for the user/Claude to pick from.
+ */
+import { callExpertAgent, SpmApiError } from '../client/spm-api.js';
+import { buildRulesPayload } from '../client/supabase.js';
+import { callJsonEndpoint } from '../client/cloud-functions.js';
+export const analyzeDefinition = {
+    name: 'spm_analyze',
+    description: 'Analyze a product document against SPM expert expectations. ' +
+        'Pass a document and a nano_app_id (e.g., "prd_critique", "user_story", "growth_strategy") ' +
+        'to get an expert analysis with expectations, sub-expectations, scores, and evidence. ' +
+        'Call spm_list_nano_apps first if you need to discover available templates. ' +
+        'Returns the full expert analysis as structured JSON.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            document: {
+                type: 'string',
+                description: 'The product document text to analyze',
+            },
+            nano_app_id: {
+                type: 'string',
+                description: 'The nano app template key (e.g., "prd_critique"). ' +
+                    'Call spm_list_nano_apps to see available options.',
+            },
+        },
+        required: ['document', 'nano_app_id'],
+    },
+};
+export async function handleAnalyze(input, apiKey) {
+    const { document, nano_app_id } = input;
+    if (!document || document.trim().length === 0) {
+        throw new SpmApiError('Document text is required', 'INVALID_INPUT');
+    }
+    if (!nano_app_id || nano_app_id.trim().length === 0) {
+        throw new SpmApiError('nano_app_id is required. Call spm_list_nano_apps to see available options.', 'INVALID_INPUT');
+    }
+    // Fetch nano app config + rules from Cloud Function (supports custom nano apps with RLS)
+    // CF returns flat object with snake_case fields — normalize to NanoApp interface (camelCase)
+    const cfResponse = await callJsonEndpoint('getNanoApp', { nano_app_id }, apiKey);
+    if (!cfResponse || !cfResponse.key) {
+        throw new SpmApiError(`Nano app '${nano_app_id}' not found. Call spm_list_nano_apps to see available options.`, 'INVALID_INPUT');
+    }
+    const nanoApp = {
+        key: cfResponse.key,
+        name: cfResponse.name,
+        description: cfResponse.description ?? null,
+        category: cfResponse.category ?? null,
+        flowType: cfResponse.flow_type ?? 'normal',
+        expectations: (cfResponse.expectations ?? []).map((e) => ({
+            id: e.id ?? '',
+            slug: e.slug ?? '',
+            name: e.name,
+            description: e.description ?? null,
+            orderIndex: e.order_index ?? 0,
+            rules: (e.rules ?? []).map((r) => ({
+                id: r.id ?? '',
+                name: r.name,
+                description: r.description ?? null,
+                spec: typeof r.spec === 'string' ? r.spec : JSON.stringify(r.spec ?? ''),
+                isDefault: true,
+                orderIndex: r.order_index ?? 0,
+            })),
+        })),
+    };
+    // Build the rules payload (same format the Chrome extension sends)
+    const rules = buildRulesPayload(nanoApp);
+    // Call the expert agent Cloud Function.
+    // userId is a label for logging — real identity comes from X-SPM-API-Key
+    // resolved by verifyAuthToken on the Cloud Function side.
+    const payload = {
+        userId: 'mcp-api-key-auth',
+        role: 'expert',
+        rules,
+        requirement_document: document,
+        review: '',
+        about_company: '',
+        user_context: '',
+        load_mode: '',
+        previously_shown_expectations: '',
+        nano_app_id,
+    };
+    const result = await callExpertAgent(payload, apiKey);
+    return {
+        nano_app_id,
+        nano_app_name: nanoApp.name,
+        analysis: result,
+    };
+}
+//# sourceMappingURL=analyze.js.map

package/dist/src/tools/clarify.d.ts

@@ -0,0 +1,65 @@
+/**
+ * spm_clarify — Clarification questions tool.
+ *
+ * Stateless: takes the document + expectations + gap context + optional previous answers,
+ * calls the clarification agent, returns questions with suggested answers.
+ *
+ * Claude's context window is the session state — each call is self-contained.
+ */
+export declare const clarifyDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            document: {
+                type: string;
+                description: string;
+            };
+            nano_app_id: {
+                type: string;
+                description: string;
+            };
+            main_expectation: {
+                type: string;
+                description: string;
+            };
+            all_sub_expectations: {
+                type: string;
+                description: string;
+            };
+            target_sub_expectation: {
+                type: string;
+                description: string;
+            };
+            previous_answers: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        question: {
+                            type: string;
+                        };
+                        answer: {
+                            type: string;
+                        };
+                    };
+                };
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export interface ClarifyInput {
+    document: string;
+    nano_app_id: string;
+    main_expectation: string;
+    all_sub_expectations: string;
+    target_sub_expectation: string;
+    previous_answers?: Array<{
+        question: string;
+        answer: string;
+    }>;
+}
+export declare function handleClarify(input: ClarifyInput, apiKey?: string): Promise<unknown>;

package/dist/src/tools/clarify.js

@@ -0,0 +1,101 @@
+/**
+ * spm_clarify — Clarification questions tool.
+ *
+ * Stateless: takes the document + expectations + gap context + optional previous answers,
+ * calls the clarification agent, returns questions with suggested answers.
+ *
+ * Claude's context window is the session state — each call is self-contained.
+ */
+import { callClarificationAgent, SpmApiError } from '../client/spm-api.js';
+export const clarifyDefinition = {
+    name: 'spm_clarify',
+    description: 'Get clarification questions for gaps identified in an SPM analysis. ' +
+        'Pass the original document, the expert analysis result (from spm_analyze), ' +
+        'and optionally previous Q&A answers. Returns targeted questions with suggested answers ' +
+        'that help close gaps in the document. ' +
+        'After the user answers, call spm_clarify again with the accumulated answers to get more questions, ' +
+        'or call spm_analyze again with the document + answers appended to get updated scores.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            document: {
+                type: 'string',
+                description: 'The original product document text',
+            },
+            nano_app_id: {
+                type: 'string',
+                description: 'The nano app template key used in the analysis',
+            },
+            main_expectation: {
+                type: 'string',
+                description: 'The main expectation name/text from the analysis result',
+            },
+            all_sub_expectations: {
+                type: 'string',
+                description: 'JSON string of all sub-expectations from the analysis. ' +
+                    'Pass the not_met_expectations array from spm_analyze result.',
+            },
+            target_sub_expectation: {
+                type: 'string',
+                description: 'The specific sub-expectation (gap) to ask about. ' +
+                    'Use the title or description of the gap you want to clarify.',
+            },
+            previous_answers: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        question: { type: 'string' },
+                        answer: { type: 'string' },
+                    },
+                },
+                description: 'Array of previous Q&A pairs from this clarification session. ' +
+                    'Pass as [{question, answer}, ...]. Empty array for first question.',
+            },
+        },
+        required: ['document', 'nano_app_id', 'main_expectation', 'all_sub_expectations', 'target_sub_expectation'],
+    },
+};
+export async function handleClarify(input, apiKey) {
+    const { document, nano_app_id, main_expectation, all_sub_expectations, target_sub_expectation, previous_answers = [], } = input;
+    if (!document?.trim()) {
+        throw new SpmApiError('Document text is required', 'INVALID_INPUT');
+    }
+    if (!nano_app_id?.trim()) {
+        throw new SpmApiError('nano_app_id is required', 'INVALID_INPUT');
+    }
+    if (!target_sub_expectation?.trim()) {
+        throw new SpmApiError('target_sub_expectation is required', 'INVALID_INPUT');
+    }
+    // Format nudgeHistory as the extension does
+    const nudgeHistory = previous_answers.map(qa => ({
+        question: qa.question,
+        answer: qa.answer,
+    }));
+    // Format prior_clarifications as condensed strings
+    const prior_clarifications = previous_answers.map(qa => `Q: ${qa.question}\nA: ${qa.answer}`);
+    // userId is a label for logging — real identity comes from X-SPM-API-Key
+    // resolved by verifyAuthToken on the Cloud Function side.
+    const payload = {
+        userId: 'mcp-api-key-auth',
+        role: 'clarification',
+        main_expectation,
+        requirement_document: document,
+        all_sub_expectations,
+        target_sub_expectation,
+        nudgeHistory,
+        prior_clarifications,
+        recent_recommendation: '',
+        latest_review: '',
+        gap_coverage: '',
+        nano_app_id,
+    };
+    const result = await callClarificationAgent(payload, apiKey);
+    return {
+        nano_app_id,
+        target_sub_expectation,
+        clarification: result,
+        round: previous_answers.length + 1,
+    };
+}
+//# sourceMappingURL=clarify.js.map

package/dist/src/tools/create-custom-nano-app.d.ts

@@ -0,0 +1,15 @@
+/**
+ * spm_create_custom_nano_app — Create a custom nano app.
+ * Routes through the createCustomNanoApp Cloud Function.
+ */
+export interface CreateCustomNanoAppInput {
+    description: string;
+    name?: string;
+    preferences?: {
+        domain_lens?: string;
+        good_bad_signals?: string;
+        clarification_style?: string;
+        improvement_format?: string;
+    };
+}
+export declare function handleCreateCustomNanoApp(input: CreateCustomNanoAppInput, apiKey?: string): Promise<unknown>;

package/dist/src/tools/create-custom-nano-app.js

@@ -0,0 +1,9 @@
+/**
+ * spm_create_custom_nano_app — Create a custom nano app.
+ * Routes through the createCustomNanoApp Cloud Function.
+ */
+import { callJsonEndpoint } from '../client/cloud-functions.js';
+export async function handleCreateCustomNanoApp(input, apiKey) {
+    return callJsonEndpoint('createCustomNanoApp', input, apiKey);
+}
+//# sourceMappingURL=create-custom-nano-app.js.map

package/dist/src/tools/evaluate.d.ts

@@ -0,0 +1,21 @@
+/**
+ * spm_evaluate — Gap evaluator tool.
+ *
+ * Stateless: takes the document + expectations + clarification answers,
+ * calls the gap evaluator agent, returns updated scores per sub-expectation.
+ *
+ * Use after 3 rounds of spm_clarify to check which gaps are now covered.
+ * The evaluator reads both the original document AND the clarification answers
+ * to produce updated scores.
+ */
+export interface EvaluateInput {
+    document: string;
+    nano_app_id: string;
+    main_expectation: string;
+    all_sub_expectations: string;
+    prior_clarifications: Array<{
+        question: string;
+        answer: string;
+    }>;
+}
+export declare function handleEvaluate(input: EvaluateInput, apiKey?: string): Promise<unknown>;

package/dist/src/tools/evaluate.js

@@ -0,0 +1,64 @@
+/**
+ * spm_evaluate — Gap evaluator tool.
+ *
+ * Stateless: takes the document + expectations + clarification answers,
+ * calls the gap evaluator agent, returns updated scores per sub-expectation.
+ *
+ * Use after 3 rounds of spm_clarify to check which gaps are now covered.
+ * The evaluator reads both the original document AND the clarification answers
+ * to produce updated scores.
+ */
+import { callEndpoint, SpmApiError } from '../client/spm-api.js';
+export async function handleEvaluate(input, apiKey) {
+    const { document, nano_app_id, main_expectation, all_sub_expectations, prior_clarifications = [], } = input;
+    if (!document?.trim()) {
+        throw new SpmApiError('Document text is required', 'INVALID_INPUT');
+    }
+    if (!nano_app_id?.trim()) {
+        throw new SpmApiError('nano_app_id is required', 'INVALID_INPUT');
+    }
+    if (!main_expectation?.trim()) {
+        throw new SpmApiError('main_expectation is required', 'INVALID_INPUT');
+    }
+    if (!all_sub_expectations?.trim()) {
+        throw new SpmApiError('all_sub_expectations is required (JSON string)', 'INVALID_INPUT');
+    }
+    // Parse all_sub_expectations — the evaluator expects an object keyed by sub-exp ID
+    let parsedSubExps;
+    try {
+        const raw = JSON.parse(all_sub_expectations);
+        // If it's an array (from spm_analyze output), convert to object keyed by id
+        if (Array.isArray(raw)) {
+            parsedSubExps = {};
+            for (const sub of raw) {
+                const id = sub.id || `sub_${Object.keys(parsedSubExps).length + 1}`;
+                parsedSubExps[id] = sub;
+            }
+        }
+        else {
+            parsedSubExps = raw;
+        }
+    }
+    catch {
+        throw new SpmApiError('all_sub_expectations must be valid JSON', 'INVALID_INPUT');
+    }
+    // Format prior_clarifications as condensed strings (same as extension)
+    const formattedClarifications = prior_clarifications.map(qa => `Q: ${qa.question}\nA: ${qa.answer}`);
+    const payload = {
+        userId: 'mcp-api-key-auth',
+        role: 'gapEvaluator',
+        main_expectation,
+        all_sub_expectations: parsedSubExps,
+        requirement_document: document,
+        prior_clarifications: formattedClarifications,
+        nano_app_id,
+    };
+    const result = await callEndpoint('extensionGapEvaluatorV3', payload, apiKey);
+    return {
+        nano_app_id,
+        main_expectation,
+        evaluation: result,
+        clarifications_evaluated: prior_clarifications.length,
+    };
+}
+//# sourceMappingURL=evaluate.js.map

package/dist/src/tools/improve.d.ts

@@ -0,0 +1,23 @@
+/**
+ * spm_improve — Improviser tool.
+ *
+ * Stateless: takes the document + expectations + clarification answers,
+ * calls the improviser agent, returns improved document content.
+ *
+ * Use after spm_evaluate confirms gaps are sufficiently covered.
+ * The improviser generates paste-ready content for each gap, grounded in
+ * the original document and the PM's clarification answers.
+ */
+export interface ImproveInput {
+    document: string;
+    nano_app_id: string;
+    main_expectation: string;
+    sub_expectation: string;
+    all_sub_expectations?: string;
+    prior_clarifications: Array<{
+        question: string;
+        answer: string;
+    }>;
+    current_content?: string;
+}
+export declare function handleImprove(input: ImproveInput, apiKey?: string): Promise<unknown>;