@planu/cli 4.1.0 → 4.1.2

package/dist/tools/tool-registry/group-integrations.js

@@ -1,1046 +0,0 @@
-/* eslint-disable max-lines -- thematic registry group consolidated by SPEC refactor-phase3 (commit aafeea60); each block is a declarative tool registration ~20 lines, split would re-create the ~120 register-*.ts files this phase intentionally collapsed */
-// tools/tool-registry/group-integrations.ts — Group D: Integration tools (inline registry)
-//
-// Phase 3 (refactor/registry-phase3): inlines register-*.ts files for:
-//   github, slack, figma, storybook, sentry, supabase, oauth, ci,
-//   pr-description, e2e-test-generator, api-spec-generator, generate-spec-from-design,
-//   living-spec, living-spec-advanced
-import { z } from 'zod';
-import { safeLicensed, safeTracked } from '../safe-handler.js';
-import { projectIdSchema, withProject } from '../tool-registry-helpers.js';
-// ── GitHub (register-github-tools.ts) ────────────────────────────────────────
-import { CreatePRFromSpecSchema, PRStatusSchema, ReviewPRSchema, CreateReleaseSchema, GenerateChangelogSchema, } from '../schemas/github.js';
-import { handleCreatePRFromSpec, handlePRStatus } from '../github-pr-handler.js';
-import { handleReviewPR } from '../github-review-handler.js';
-import { handleCreateRelease, handleGenerateChangelog } from '../github-release-handler.js';
-// ── Slack (register-slack-tools.ts) ──────────────────────────────────────────
-import { handleConfigureSlack, handleSlackNotify, handleSlackStatus, handleRemoveSlack, } from '../slack-handler.js';
-// ── Figma (register-figma-tools.ts) ──────────────────────────────────────────
-import { handleConfigureFigma, handleFigmaStatus, handleListFigmaFrames, handleGenerateSpecsFromFigma, handleAnalyzeFigmaFlows, handleExtractFigmaDesignTokens, handleSyncFigmaChanges, handleListFigmaResponsiveFrames, handleConfigureFigmaWebhook, handleRemoveFigmaWebhook, handleSyncFigmaCodeConnect, handleAddFigmaFile, handleRemoveFigmaFile, handleListFigmaFiles, handleCheckFigmaDesignDrift, handleFigmaVisualDiffReport, handleGenerateFigmaE2ETests, handleEnrichSpecsFromFigma, handleGetFigmaContextForSpec, handleImportFigmaProject, } from '../figma-handler.js';
-import { handleSyncFigmaTokensToCode, handleValidateTokenConsistency, } from '../figma-token-handler.js';
-import { handleGenerateFigmaRulesFile } from '../figma/rules-file.js';
-// ── Storybook (register-storybook-tools.ts) ───────────────────────────────────
-import { handleSyncStorybook, handleListStorybookComponents, handleInjectComponentContext, } from '../storybook-handler.js';
-// ── Sentry (register-sentry-tools.ts) ────────────────────────────────────────
-import { handleConfigureSentry, handleSentryStatus, handleSentryErrorsReport, handleSentryErrorToSpec, } from '../sentry-handler.js';
-// ── Supabase (register-supabase-tools.ts) ────────────────────────────────────
-import { handleConfigureSupabase, handleSupabaseStatus, handleSyncSupabaseSchema, handleGenerateRlsSpec, } from '../supabase-handler.js';
-import { handleApproveTestimonial, handleListTestimonials } from '../testimonial-handler.js';
-// ── OAuth (register-oauth-tools.ts) ──────────────────────────────────────────
-import { handleConfigureOAuth } from '../configure-oauth-handler.js';
-import { handleStartOAuthFlow, handleOAuthStatus, StartOAuthFlowInputSchema, OAuthStatusInputSchema, } from '../oauth-handler.js';
-// ── CI (register-ci-tools.ts) ─────────────────────────────────────────────────
-import { handleGenerateCI } from '../ci-generator.js';
-import { handleGeneratePlanuCI } from '../ci-planu-handler.js';
-// ── PR Description (register-pr-description-tools.ts) ────────────────────────
-import { handleGeneratePrDescription, handleLinkPrToSpec, handleListSpecPrs, } from '../pr-description-handler.js';
-// ── E2E Test Generator (register-e2e-test-generator-tools.ts) ────────────────
-import { handleGenerateE2eTests, handleE2eTestStatus } from '../e2e-test-generator-handler.js';
-// ── API Spec Generator (register-api-spec-generator.ts) ──────────────────────
-import { handleGenerateSpecFromApi } from '../api-spec-generator-handler.js';
-// ── Generate Spec From Design (register-generate-spec-from-design.ts) ─────────
-import { handleGenerateSpecFromDesign } from '../generate-spec-from-design.js';
-// ── Living Spec (register-living-spec-tools.ts) ───────────────────────────────
-import { handleValidateAnnotations } from '../validate-annotations.js';
-import { handleGenerateAnnotations } from '../generate-annotations.js';
-import { handleSnapshotSpecHashes } from '../snapshot-spec-hashes.js';
-import { handleAutoReconcile } from '../auto-reconcile.js';
-// ── Living Spec Advanced (register-living-spec-advanced-tools.ts) ─────────────
-import { handleLivingSpecWatch, handleLivingSpecStatus } from '../living-spec-watch.js';
-import { handleSpecDiff } from '../spec-diff.js';
-import { handleLivingSpecCoverage } from '../living-spec-coverage.js';
-import { handleSyncSpecToCode } from '../sync-spec-to-code.js';
-import { handleSyncCodeToSpec } from '../sync-code-to-spec.js';
-import { handleResolveSyncConflict } from '../resolve-sync-conflict.js';
-// eslint-disable-next-line max-lines-per-function -- registration catalog: one block per tool. ~34 tools from 14 register-*.ts files.
-export function registerIntegrationsGroupTools(s) {
-    // ── GitHub ──────────────────────────────────────────────────────────────────
-    s.registerTool('create_pr_from_spec', {
-        description: 'Create a GitHub Pull Request from a spec. Extracts title and body from spec.md, ' +
-            'detects the current branch as head, and links it to the spec via branch naming convention.',
-        inputSchema: CreatePRFromSpecSchema.shape,
-        annotations: { title: 'Create PR from Spec', readOnlyHint: false },
-    }, safeLicensed('create_pr_from_spec', async (args) => handleCreatePRFromSpec(args)));
-    s.registerTool('pr_status', {
-        description: 'List open Pull Requests with review status and CI checks. ' +
-            'Query by PR number, spec ID, or list all open PRs. ' +
-            'Supports views: prs (default) | milestones.',
-        inputSchema: PRStatusSchema.shape,
-        annotations: { title: 'PR Status', readOnlyHint: true },
-    }, safeTracked('pr_status', async (args) => handlePRStatus(args)));
-    s.registerTool('review_pr', {
-        description: 'Analyze a Pull Request diff for review findings. ' +
-            'Supports review types: summary | detailed | security | performance | expert | quality. ' +
-            'Use expert for multi-dimensional analysis (architecture, security, tests, conventions, spec-drift). ' +
-            'Use quality for semantic code quality analysis (duplication, complexity, dead-code). ' +
-            'Does NOT post comments — returns analysis for the user to decide.',
-        inputSchema: ReviewPRSchema.shape,
-        annotations: { title: 'Review PR', readOnlyHint: true },
-    }, safeLicensed('review_pr', async (args) => handleReviewPR(args)));
-    s.registerTool('create_release', {
-        description: 'Create a GitHub Release with tag and auto-generated release notes from merged PRs. ' +
-            'Creates a git tag with the specified semver version.',
-        inputSchema: CreateReleaseSchema.shape,
-        annotations: { title: 'Create Release', readOnlyHint: false, destructiveHint: true },
-    }, safeLicensed('create_release', async (args) => handleCreateRelease(args)));
-    s.registerTool('generate_changelog', {
-        description: 'Generate a changelog from merged Pull Requests between two git refs. ' +
-            'Groups by type (feat, fix, docs, etc.) using conventional commit prefixes. ' +
-            'Output format: markdown (Keep a Changelog) | json.',
-        inputSchema: GenerateChangelogSchema.shape,
-        annotations: { title: 'Generate Changelog', readOnlyHint: true },
-    }, safeLicensed('generate_changelog', async (args) => handleGenerateChangelog(args)));
-    // ── Slack ───────────────────────────────────────────────────────────────────
-    s.registerTool('configure_slack', {
-        description: 'Configure a Slack incoming webhook for this project. Once configured, spec status changes will automatically send rich Block Kit notifications to your Slack channel.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .describe('Absolute path to the project root (e.g. /home/user/my-project).'),
-            webhookUrl: z
-                .url()
-                .describe('Slack incoming webhook URL (e.g. https://hooks.slack.com/services/T.../B.../...).'),
-            channel: z
-                .string()
-                .optional()
-                .describe('Optional channel override (e.g. #deployments). If omitted, uses the webhook default.'),
-        },
-        annotations: { title: 'Configure Slack', destructiveHint: false },
-    }, safeTracked('configure_slack', async (args) => handleConfigureSlack(args)));
-    s.registerTool('slack_notify', {
-        description: 'Send a manual Slack notification to the configured webhook. Optionally link the message to a specific spec.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .describe('Absolute path to the project root (e.g. /home/user/my-project).'),
-            message: z.string().min(1).describe('Notification message text to send to Slack.'),
-            specId: z
-                .string()
-                .optional()
-                .describe('Optional SPEC-XXX identifier to link this notification to a spec.'),
-        },
-        annotations: { title: 'Slack Notify', destructiveHint: false },
-    }, safeTracked('slack_notify', async (args) => handleSlackNotify(args)));
-    s.registerTool('slack_status', {
-        description: 'Show the current Slack configuration and the last 20 notification delivery records for this project.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .describe('Absolute path to the project root (e.g. /home/user/my-project).'),
-        },
-        annotations: { title: 'Slack Status', readOnlyHint: true },
-    }, safeTracked('slack_status', async (args) => handleSlackStatus(args)));
-    s.registerTool('remove_slack', {
-        description: 'Remove the Slack webhook configuration for this project. Notifications will stop immediately.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .describe('Absolute path to the project root (e.g. /home/user/my-project).'),
-        },
-        annotations: { title: 'Remove Slack', destructiveHint: true },
-    }, safeTracked('remove_slack', async (args) => handleRemoveSlack(args)));
-    // ── Figma ───────────────────────────────────────────────────────────────────
-    s.registerTool('configure_figma', {
-        description: 'Connect a Figma Personal Access Token (PAT) to this project. ' +
-            'The token is verified against the Figma API before saving. ' +
-            'Once configured, you can list frames and generate specs from Figma files.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root directory.'),
-            accessToken: z
-                .string()
-                .min(1)
-                .describe('Figma Personal Access Token (PAT). Generate one at figma.com → Account Settings → Access tokens.'),
-        },
-        annotations: { title: 'Configure Figma', destructiveHint: false },
-    }, safeLicensed('configure_figma', async (args) => handleConfigureFigma(args)));
-    s.registerTool('figma_status', {
-        description: 'Show the current Figma configuration and the last 3 sync log entries for this project.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root directory.'),
-        },
-        annotations: { title: 'Figma Status', readOnlyHint: true },
-    }, safeTracked('figma_status', async (args) => handleFigmaStatus(args)));
-    s.registerTool('list_figma_frames', {
-        description: 'List all frames in a Figma file, grouped by section prefix. ' +
-            'Use this to preview the structure before generating specs.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root directory.'),
-            figmaUrl: z
-                .url()
-                .describe('URL of the Figma file (e.g. https://www.figma.com/design/FILEID/FileName).'),
-        },
-        annotations: { title: 'List Figma Frames', readOnlyHint: true },
-    }, safeTracked('list_figma_frames', async (args) => handleListFigmaFrames(args)));
-    s.registerTool('generate_specs_from_figma_file', {
-        description: 'Generate Planu specs from frames in a Figma file. ' +
-            'Frames are grouped into sections (by name prefix or page) and one spec is created per section. ' +
-            'Use sectionFilter to process only a subset of sections.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root directory.'),
-            figmaUrl: z
-                .url()
-                .describe('URL of the Figma file (e.g. https://www.figma.com/design/FILEID/FileName).'),
-            groupBy: z
-                .enum(['prefix', 'page'])
-                .optional()
-                .describe('How to group frames into sections. Values: prefix — group by name prefix (default), page — group by Figma page.'),
-            sectionFilter: z
-                .string()
-                .optional()
-                .describe('Optional prefix filter. Only frames whose section matches this string will be processed.'),
-        },
-        annotations: { title: 'Generate Specs from Figma File', destructiveHint: false },
-    }, safeLicensed('generate_specs_from_figma_file', async (args) => handleGenerateSpecsFromFigma(args)));
-    s.registerTool('analyze_figma_flows', {
-        description: 'Extract prototype interaction flows from a Figma file. Saves the flow graph locally for use by generate_figma_e2e_tests.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root.'),
-            figmaUrl: z.url().describe('Figma file URL.'),
-        },
-        annotations: { title: 'Analyze Figma Flows' },
-    }, safeLicensed('analyze_figma_flows', async (args) => handleAnalyzeFigmaFlows(args)));
-    s.registerTool('extract_figma_design_tokens', {
-        description: 'Extract design tokens (colors, typography, spacing, radii) from Figma variables and save as structured JSON.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root.'),
-            figmaUrl: z.url().describe('Figma file URL.'),
-        },
-        annotations: { title: 'Extract Figma Design Tokens' },
-    }, safeLicensed('extract_figma_design_tokens', async (args) => handleExtractFigmaDesignTokens(args)));
-    s.registerTool('sync_figma_changes', {
-        description: 'Detect renamed or moved frames since the last sync. Takes a new snapshot and reports the diff.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root.'),
-            figmaUrl: z.url().describe('Figma file URL.'),
-        },
-        annotations: { title: 'Sync Figma Changes' },
-    }, safeLicensed('sync_figma_changes', async (args) => handleSyncFigmaChanges(args)));
-    s.registerTool('list_figma_responsive_frames', {
-        description: 'List frames grouped by breakpoint (mobile/tablet/desktop) based on page name or frame name suffix.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root.'),
-            figmaUrl: z.url().describe('Figma file URL.'),
-        },
-        annotations: { title: 'List Figma Responsive Frames', readOnlyHint: true },
-    }, safeLicensed('list_figma_responsive_frames', async (args) => handleListFigmaResponsiveFrames(args)));
-    s.registerTool('configure_figma_webhook', {
-        description: 'Register a Figma webhook to receive notifications when the file changes.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root.'),
-            teamId: z.string().min(1).describe('Figma team ID (visible in team URL).'),
-            callbackUrl: z.url().describe('Public HTTPS URL to receive webhook events.'),
-        },
-        annotations: { title: 'Configure Figma Webhook' },
-    }, safeLicensed('configure_figma_webhook', async (args) => handleConfigureFigmaWebhook(args)));
-    s.registerTool('remove_figma_webhook', {
-        description: 'Deregister a previously configured Figma webhook.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root.'),
-            webhookId: z
-                .string()
-                .min(1)
-                .describe('Webhook ID to remove (from configure_figma_webhook output).'),
-        },
-        annotations: { title: 'Remove Figma Webhook', destructiveHint: true },
-    }, safeLicensed('remove_figma_webhook', async (args) => handleRemoveFigmaWebhook(args)));
-    s.registerTool('sync_figma_code_connect', {
-        description: 'Fetch Figma Code Connect mappings linking design components to codebase components.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root.'),
-            figmaUrl: z.url().describe('Figma file URL.'),
-        },
-        annotations: { title: 'Sync Figma Code Connect' },
-    }, safeLicensed('sync_figma_code_connect', async (args) => handleSyncFigmaCodeConnect(args)));
-    s.registerTool('add_figma_file', {
-        description: 'Register an additional Figma file for this project (multi-file support).',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root.'),
-            figmaUrl: z.url().describe('Figma file URL to add.'),
-            label: z
-                .string()
-                .min(1)
-                .describe('Short label to identify this file (e.g. "Design System", "Checkout").'),
-        },
-        annotations: { title: 'Add Figma File' },
-    }, safeLicensed('add_figma_file', async (args) => handleAddFigmaFile(args)));
-    s.registerTool('remove_figma_file', {
-        description: 'Remove a registered Figma file from this project.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root.'),
-            fileKey: z.string().min(1).describe('Figma file key to remove.'),
-        },
-        annotations: { title: 'Remove Figma File', destructiveHint: true },
-    }, safeLicensed('remove_figma_file', async (args) => handleRemoveFigmaFile(args)));
-    s.registerTool('list_figma_files', {
-        description: 'List all Figma files registered for this project.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root.'),
-        },
-        annotations: { title: 'List Figma Files', readOnlyHint: true },
-    }, safeTracked('list_figma_files', async (args) => handleListFigmaFiles(args)));
-    s.registerTool('check_figma_design_drift', {
-        description: 'Check if Figma specs are out of date with the latest Figma file version.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root.'),
-            figmaUrl: z.url().describe('Figma file URL.'),
-        },
-        annotations: { title: 'Check Figma Design Drift', readOnlyHint: true },
-    }, safeLicensed('check_figma_design_drift', async (args) => handleCheckFigmaDesignDrift(args)));
-    s.registerTool('figma_visual_diff_report', {
-        description: 'Export Figma frame images and generate a visual QA report comparing design vs implementation.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root.'),
-            figmaUrl: z.url().describe('Figma file URL.'),
-            specId: z
-                .string()
-                .min(1)
-                .describe('Spec ID to validate (must have been generated from Figma).'),
-        },
-        annotations: { title: 'Figma Visual Diff Report' },
-    }, safeLicensed('figma_visual_diff_report', async (args) => handleFigmaVisualDiffReport(args)));
-    s.registerTool('generate_figma_e2e_tests', {
-        description: 'Generate Playwright E2E test files from Figma prototype flows.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root.'),
-            figmaUrl: z.url().describe('Figma file URL.'),
-            outputDir: z
-                .string()
-                .optional()
-                .describe('Output directory for test files relative to projectPath. Default: e2e/figma'),
-            sectionFilter: z
-                .string()
-                .optional()
-                .describe('Only generate tests for flows in this section.'),
-        },
-        annotations: { title: 'Generate Figma E2E Tests' },
-    }, safeLicensed('generate_figma_e2e_tests', async (args) => handleGenerateFigmaE2ETests(args)));
-    s.registerTool('enrich_specs_from_figma', {
-        description: 'Enrich existing Planu specs with design context from Figma (component hints, layout notes, colors).',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root.'),
-            figmaUrl: z.url().describe('Figma file URL.'),
-            specIds: z
-                .array(z.string())
-                .optional()
-                .describe('Specific spec IDs to enrich. If omitted, enriches all Figma-generated specs.'),
-        },
-        annotations: { title: 'Enrich Specs from Figma' },
-    }, safeLicensed('enrich_specs_from_figma', async (args) => handleEnrichSpecsFromFigma(args)));
-    s.registerTool('get_figma_context_for_spec', {
-        description: 'Get stored design context for a specific spec during implementation.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root.'),
-            specId: z.string().min(1).describe('Spec ID to get design context for.'),
-        },
-        annotations: { title: 'Get Figma Context for Spec', readOnlyHint: true },
-    }, safeLicensed('get_figma_context_for_spec', async (args) => handleGetFigmaContextForSpec(args)));
-    s.registerTool('import_figma_project', {
-        description: 'One-command Figma import: fetches frames, extracts flows, generates specs, enriches with design context, and tracks version.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root.'),
-            figmaUrl: z.url().describe('Figma file URL.'),
-            teamId: z
-                .string()
-                .optional()
-                .describe('Figma team ID (required only if you want to configure webhooks).'),
-            webhookCallbackUrl: z
-                .url()
-                .optional()
-                .describe('Public HTTPS callback URL for Figma webhooks (optional).'),
-        },
-        annotations: { title: 'Import Figma Project' },
-    }, safeLicensed('import_figma_project', async (args) => handleImportFigmaProject(args)));
-    s.registerTool('sync_figma_tokens_to_code', {
-        description: 'Write Figma design tokens to a CSS, TypeScript, or JSON file in the project. Run extract_figma_design_tokens first to fetch tokens from Figma.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root.'),
-            format: z
-                .enum(['css', 'ts', 'json'])
-                .describe('Output format. Values: css — CSS custom properties (:root {}), ts — TypeScript const object, json — W3C Design Token Format (DTCG).'),
-            outputPath: z
-                .string()
-                .min(1)
-                .describe('Output file path relative to projectPath (e.g. "src/styles/tokens.css").'),
-            prefix: z
-                .string()
-                .optional()
-                .describe('CSS variable prefix (only for css format). Default: planu.'),
-        },
-        annotations: { title: 'Sync Figma Tokens to Code' },
-    }, safeLicensed('sync_figma_tokens_to_code', async (args) => handleSyncFigmaTokensToCode(args)));
-    s.registerTool('validate_token_consistency', {
-        description: 'Compare stored Figma tokens against an existing token file to detect drift (tokens out of sync with the design).',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root.'),
-            format: z
-                .enum(['css', 'ts', 'json'])
-                .describe('Format of the token file. Values: css, ts, json.'),
-            filePath: z
-                .string()
-                .min(1)
-                .describe('Absolute path to the existing token file to validate.'),
-        },
-        annotations: { title: 'Validate Token Consistency', readOnlyHint: true },
-    }, safeLicensed('validate_token_consistency', async (args) => handleValidateTokenConsistency(args)));
-    s.registerTool('generate_figma_rules_file', {
-        description: 'Generate .claude/rules/figma-design-system.md in the client project with the official Figma MCP implementation rules. ' +
-            'Includes: localhost asset rules (no placeholders), no icon package installs, Code Connect component map, ' +
-            'design token names, and stack-adapted output guidance. ' +
-            'Run after configure_figma and sync_figma_code_connect to keep the rules file up to date.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .min(1)
-                .max(4096)
-                .describe('Absolute path to the project root where .claude/rules/ will be created.'),
-        },
-        annotations: { title: 'Generate Figma Rules File', readOnlyHint: false },
-    }, safeLicensed('generate_figma_rules_file', async (args) => handleGenerateFigmaRulesFile(args)));
-    // ── Storybook ───────────────────────────────────────────────────────────────
-    s.registerTool('sync_storybook_components', {
-        description: 'Scan a project for .stories.ts/.stories.tsx/.stories.js/.stories.jsx files and extract ' +
-            'a structured catalog of UI components, stories, and props. Saves the catalog for later queries.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .min(1)
-                .describe('Absolute path to the project root directory to scan for story files.'),
-        },
-        annotations: { title: 'Sync Storybook Components', destructiveHint: false },
-    }, safeLicensed('sync_storybook_components', async (args) => handleSyncStorybook(args)));
-    s.registerTool('list_storybook_components', {
-        description: 'Show the stored Storybook component catalog for a project. ' +
-            'Run sync_storybook_components first to populate the catalog.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root directory.'),
-        },
-        annotations: { title: 'List Storybook Components', readOnlyHint: true },
-    }, safeLicensed('list_storybook_components', async (args) => handleListStorybookComponents(args)));
-    s.registerTool('inject_component_context', {
-        description: 'Find Storybook components matching a query string (name, category, or title). ' +
-            'Returns matching components with their stories and props for use in spec enrichment.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root directory.'),
-            query: z
-                .string()
-                .min(1)
-                .describe('Search query to filter components by name, category, or title. ' +
-                'Case-insensitive. Examples: "button", "auth", "UI".'),
-        },
-        annotations: { title: 'Inject Component Context', readOnlyHint: true },
-    }, safeLicensed('inject_component_context', async (args) => handleInjectComponentContext(args)));
-    // ── Sentry ──────────────────────────────────────────────────────────────────
-    s.registerTool('configure_sentry', {
-        description: 'Configure Sentry error monitoring integration for this project. Requires a Sentry DSN, auth token, organization slug, and project slug.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .describe('Absolute path to the project root (e.g. /home/user/my-project).'),
-            dsn: z
-                .string()
-                .describe('Sentry DSN URL for the project (e.g. https://...@sentry.io/...).'),
-            authToken: z
-                .string()
-                .describe('Sentry auth token with project:read and event:read scopes.'),
-            organizationSlug: z.string().describe('Sentry organization slug (e.g. my-org).'),
-            projectSlug: z.string().describe('Sentry project slug (e.g. my-project).'),
-        },
-        annotations: { title: 'Configure Sentry', destructiveHint: false },
-    }, safeTracked('configure_sentry', async (args) => handleConfigureSentry(args)));
-    s.registerTool('sentry_status', {
-        description: 'Show the current Sentry configuration for this project.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .describe('Absolute path to the project root (e.g. /home/user/my-project).'),
-        },
-        annotations: { title: 'Sentry Status', readOnlyHint: true },
-    }, safeTracked('sentry_status', async (args) => handleSentryStatus(args)));
-    s.registerTool('sentry_errors_report', {
-        description: 'Fetch and display a report of recent Sentry issues for this project. Supports filtering by level and unresolved status. Requires Sentry configured via configure_sentry.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .describe('Absolute path to the project root (e.g. /home/user/my-project).'),
-            limit: z
-                .number()
-                .int()
-                .min(1)
-                .max(100)
-                .optional()
-                .describe('Maximum number of issues to fetch (default: 10, max: 100).'),
-            level: z
-                .enum(['fatal', 'error', 'warning', 'info', 'debug'])
-                .optional()
-                .describe('Filter by error level. Valid values: fatal, error, warning, info, debug.'),
-            unresolved: z.boolean().optional().describe('Only show unresolved issues (default: true).'),
-        },
-        annotations: { title: 'Sentry Errors Report', readOnlyHint: true },
-    }, safeLicensed('sentry_errors_report', async (args) => handleSentryErrorsReport(args)));
-    s.registerTool('sentry_error_to_spec', {
-        description: 'Convert a Sentry issue into a Planu bugfix spec. Fetches the issue details and stacktrace, generates acceptance criteria, and creates a spec automatically. Requires Sentry configured via configure_sentry.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .describe('Absolute path to the project root (e.g. /home/user/my-project).'),
-            issueId: z.string().describe('Sentry issue ID (numeric string, e.g. "12345678").'),
-            priority: z
-                .enum(['low', 'medium', 'high', 'critical'])
-                .optional()
-                .describe('Override the auto-detected priority. Valid values: low, medium, high, critical. Auto-detected from Sentry level if omitted.'),
-        },
-        annotations: { title: 'Sentry Error to Spec', destructiveHint: false },
-    }, safeLicensed('sentry_error_to_spec', async (args) => handleSentryErrorToSpec(args)));
-    // ── Supabase ────────────────────────────────────────────────────────────────
-    s.registerTool('configure_supabase', {
-        description: 'Connect a Supabase project to Planu by saving the project URL and service role key. ' +
-            'Once configured, you can sync the database schema and generate security specs.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root directory.'),
-            projectUrl: z
-                .string()
-                .min(1)
-                .describe('Supabase project URL (e.g. https://abc123.supabase.co).'),
-            serviceRoleKey: z
-                .string()
-                .min(1)
-                .describe('Supabase service role key (from Project Settings → API).'),
-            anonKey: z
-                .string()
-                .optional()
-                .describe('Supabase anon/public key (optional, from Project Settings → API).'),
-        },
-        annotations: { title: 'Configure Supabase', destructiveHint: false },
-    }, safeTracked('configure_supabase', async (args) => handleConfigureSupabase(args)));
-    s.registerTool('supabase_status', {
-        description: 'Show the current Supabase configuration and last schema sync summary for this project.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root directory.'),
-        },
-        annotations: { title: 'Supabase Status', readOnlyHint: true },
-    }, safeTracked('supabase_status', async (args) => handleSupabaseStatus(args)));
-    s.registerTool('sync_supabase_schema', {
-        description: 'Fetch the Supabase database schema (tables, columns, RLS policies) and store it locally. ' +
-            'Run this before generate_rls_spec to get up-to-date schema information.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root directory.'),
-            schemas: z
-                .array(z.string())
-                .optional()
-                .describe('Database schemas to include. Values: public, auth, etc. Default: ["public"].'),
-        },
-        annotations: { title: 'Sync Supabase Schema', destructiveHint: false },
-    }, safeLicensed('sync_supabase_schema', async (args) => handleSyncSupabaseSchema(args)));
-    s.registerTool('generate_rls_spec', {
-        description: 'Generate Planu security specs from Supabase RLS (Row Level Security) policies. ' +
-            'Creates one spec per table with acceptance criteria derived from the actual policies. ' +
-            'Run sync_supabase_schema first.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root directory.'),
-            tableName: z
-                .string()
-                .optional()
-                .describe('Generate spec only for this table. If omitted, processes all synced tables.'),
-            createMissingRlsSpecs: z
-                .boolean()
-                .optional()
-                .describe('When true (default), also creates specs for tables that have no RLS policies, flagging them as critical security gaps.'),
-        },
-        annotations: { title: 'Generate RLS Spec', destructiveHint: false },
-    }, safeLicensed('generate_rls_spec', async (args) => handleGenerateRlsSpec(args)));
-    s.registerTool('approve_testimonial', {
-        description: 'Approve a testimonial for display on planu.dev. Accepts feedback_id to promote existing feedback, ' +
-            'or manual data (authorName, quote, rating) for new testimonials.',
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root directory.'),
-            feedbackId: z
-                .string()
-                .optional()
-                .describe('ID of existing feedback to promote as a testimonial.'),
-            authorName: z.string().optional().describe('Display name of the testimonial author.'),
-            authorRole: z
-                .string()
-                .optional()
-                .describe('Job title or role of the author (e.g. "Senior Engineer at Acme").'),
-            authorAvatarUrl: z
-                .string()
-                .optional()
-                .describe('URL of the author avatar image (public URL).'),
-            authorGithub: z.string().optional().describe('GitHub username of the author (without @).'),
-            quote: z.string().optional().describe('The testimonial text to display on planu.dev.'),
-            rating: z
-                .number()
-                .int()
-                .min(1)
-                .max(5)
-                .optional()
-                .describe('Star rating between 1 and 5 (inclusive). Default: 5.'),
-            source: z
-                .enum(['github', 'twitter', 'linkedin', 'email', 'manual'])
-                .optional()
-                .describe('Origin of the testimonial. Values: github, twitter, linkedin, email, manual. Default: manual.'),
-            featured: z
-                .boolean()
-                .optional()
-                .describe('Whether to feature this testimonial prominently on planu.dev. Default: false.'),
-            locale: z
-                .string()
-                .optional()
-                .describe('Locale code for the testimonial language (e.g. "en", "es"). Default: en.'),
-            projectType: z
-                .string()
-                .optional()
-                .describe('Type of project the author used Planu for (e.g. "saas", "mobile", "enterprise").'),
-            companySize: z
-                .string()
-                .optional()
-                .describe('Company size category (e.g. "1-10", "11-50", "51-200", "200+").'),
-        },
-        annotations: { title: 'Approve Testimonial', destructiveHint: false },
-    }, safeLicensed('approve_testimonial', async (args) => handleApproveTestimonial(args)));
-    s.registerTool('list_testimonials', {
-        description: "List testimonials from Supabase with filters. Use to audit what's shown on planu.dev.",
-        inputSchema: {
-            projectPath: z.string().min(1).describe('Absolute path to the project root directory.'),
-            filter: z
-                .enum(['approved', 'pending', 'all'])
-                .optional()
-                .describe('Filter testimonials by approval status. Values: approved (default), pending, all.'),
-            locale: z.string().optional().describe('Filter by locale code (e.g. "en", "es").'),
-            featured: z.boolean().optional().describe('When true, only return featured testimonials.'),
-            source: z
-                .enum(['github', 'twitter', 'linkedin', 'email', 'manual'])
-                .optional()
-                .describe('Filter by testimonial source. Values: github, twitter, linkedin, email, manual.'),
-            limit: z
-                .number()
-                .int()
-                .min(1)
-                .max(200)
-                .optional()
-                .describe('Maximum number of testimonials to return (default: 50, max: 200).'),
-        },
-        annotations: { title: 'List Testimonials', readOnlyHint: true },
-    }, safeLicensed('list_testimonials', async (args) => handleListTestimonials(args)));
-    // ── OAuth ───────────────────────────────────────────────────────────────────
-    s.registerTool('configure_oauth', {
-        description: 'Check or test the OAuth / API-key authentication protecting this MCP server. ' +
-            'Use action=status to see which env vars are set, action=test to validate a token.',
-        inputSchema: {
-            action: z
-                .enum(['status', 'test'])
-                .describe('Action to perform. Values: status=show current config, test=validate a token'),
-            token: z.string().optional().describe('Token to validate (only used with action=test)'),
-        },
-    }, safeTracked('configure_oauth', (input) => handleConfigureOAuth(input)));
-    s.registerTool('start_oauth_flow', {
-        description: 'Inicia el flujo de autorización para conectar Figma, GitHub, Sentry o Supabase. ' +
-            'Para Figma y GitHub abre un link OAuth. Para Sentry y Supabase proporciona instrucciones ' +
-            'paso a paso. La autorización se guarda automáticamente.',
-        inputSchema: StartOAuthFlowInputSchema,
-        annotations: { title: 'Start OAuth Flow' },
-    }, safeTracked('start_oauth_flow', (input) => handleStartOAuthFlow(input)));
-    s.registerTool('oauth_status', {
-        description: 'Muestra qué integraciones están autorizadas y cuándo expiran sus tokens.',
-        inputSchema: OAuthStatusInputSchema,
-        annotations: { title: 'OAuth Status', readOnlyHint: true },
-    }, safeTracked('oauth_status', (input) => handleOAuthStatus(input)));
-    // ── CI ──────────────────────────────────────────────────────────────────────
-    s.registerTool('generate_ci', {
-        description: 'Generate a GitHub Actions CI workflow YAML for a project. Auto-detects ecosystem (Node.js, Python, Go, Rust, Java/Kotlin, Ruby, PHP, Dart, .NET) and configures lint, test, build, and deploy jobs with proper caching and dependency installation.',
-        inputSchema: {
-            ...projectIdSchema,
-            jobs: z
-                .array(z
-                .enum(['lint', 'test', 'build', 'deploy'])
-                .describe('Job type: lint | test | build | deploy'))
-                .max(100)
-                .optional()
-                .describe('CI jobs to include. Defaults to [lint, test, build]. Valid values: lint | test | build | deploy'),
-            triggers: z
-                .array(z
-                .enum(['push', 'pull_request', 'workflow_dispatch', 'schedule'])
-                .describe('Trigger: push | pull_request | workflow_dispatch | schedule'))
-                .max(100)
-                .optional()
-                .describe('GitHub Actions triggers. Defaults to [push, pull_request]. Valid values: push | pull_request | workflow_dispatch | schedule'),
-            nodeVersion: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Node.js version to use (e.g. "20", "22"). Auto-detected from .nvmrc or package.json if omitted'),
-            pythonVersion: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Python version to use (e.g. "3.11", "3.12"). Auto-detected from .python-version or pyproject.toml if omitted'),
-            goVersion: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Go version to use (e.g. "1.22", "1.23"). Auto-detected from go.mod if omitted'),
-            rustChannel: z
-                .enum(['stable', 'beta', 'nightly'])
-                .optional()
-                .describe('Rust toolchain channel: stable | beta | nightly. Auto-detected from rust-toolchain.toml if omitted'),
-            javaVersion: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Java version to use (e.g. "21", "17"). Auto-detected from pom.xml or build.gradle if omitted'),
-            workflowName: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Name for the GitHub Actions workflow (default: "CI"). Used as the workflow name and filename'),
-        },
-        annotations: { readOnlyHint: true },
-    }, safeLicensed('generate_ci', withProject((args) => handleGenerateCI(args))));
-    s.registerTool('generate_planu_ci', {
-        description: 'Generate a Planu-specific GitHub Actions CI workflow that validates specs, detects drift between code and specs, posts results as PR comments, generates badges, and supports .planu.yml configuration. Produces ready-to-use workflow YAML + config file.',
-        inputSchema: {
-            ...projectIdSchema,
-            specsDir: z
-                .string()
-                .max(4096)
-                .optional()
-                .describe('Directory containing specs (default: "docs/sdd/specs")'),
-            detectDrift: z
-                .boolean()
-                .optional()
-                .describe('Enable drift detection between code changes and specs (default: true)'),
-            failOnDrift: z
-                .boolean()
-                .optional()
-                .describe('Exit with code 1 when drift/issues detected above threshold (default: true)'),
-            severityThreshold: z
-                .enum(['critical', 'warning', 'info'])
-                .optional()
-                .describe('Severity threshold for CI failure: critical | warning | info (default: "warning"). critical = only mandatory broken specs; warning = any drift or incomplete criteria; info = always passes'),
-            postComment: z
-                .boolean()
-                .optional()
-                .describe('Post/update a markdown results comment on PRs (default: true)'),
-            badge: z
-                .boolean()
-                .optional()
-                .describe('Generate a shields.io badge endpoint for README (default: true)'),
-            workingDirectory: z
-                .string()
-                .max(4096)
-                .optional()
-                .describe('Working directory for monorepo projects (default: ".")'),
-            includeGithubActions: z
-                .boolean()
-                .optional()
-                .describe('Include GitHub Actions workflow YAML (default: true). Set false for users without GitHub billing — a local planu-check.sh script is always generated regardless.'),
-            gitHook: z
-                .boolean()
-                .optional()
-                .describe('Mark for git pre-push hook integration in the output instructions (default: false)'),
-        },
-        annotations: { readOnlyHint: true },
-    }, safeLicensed('generate_planu_ci', withProject((args) => Promise.resolve(handleGeneratePlanuCI(args)))));
-    // ── PR Description ──────────────────────────────────────────────────────────
-    s.registerTool('generate_pr_description', {
-        description: 'Generates a pull request description in markdown from a Planu spec. ' +
-            'Supports GitHub, GitLab, and Linear formats. Includes title suggestion, labels, ' +
-            'acceptance criteria link, test plan, and optional checklist.',
-        annotations: { title: 'Generate PR Description', readOnlyHint: true },
-        inputSchema: {
-            projectPath: z
-                .string()
-                .describe('Absolute path to the project root containing planu/specs/'),
-            specId: z.string().describe('Spec ID to generate PR description from (e.g. SPEC-042)'),
-            platform: z
-                .enum(['github', 'gitlab', 'linear'])
-                .optional()
-                .describe('Target platform for the PR description. Valid values: github, gitlab, linear. Default: github'),
-            audience: z
-                .enum(['developer', 'reviewer', 'stakeholder'])
-                .optional()
-                .describe('Intended audience for the description. Valid values: developer, reviewer, stakeholder. Default: reviewer'),
-            includeChecklist: z
-                .boolean()
-                .optional()
-                .describe('Whether to include a pre-merge checklist section. Default: true'),
-        },
-    }, safeTracked('generate_pr_description', (args) => handleGeneratePrDescription(args)));
-    s.registerTool('link_pr_to_spec', {
-        description: 'Links a pull request URL to a Planu spec for traceability. ' +
-            'Records the PR number, URL, and platform. Use list_spec_prs to view all linked PRs.',
-        annotations: { title: 'Link PR to Spec', destructiveHint: false },
-        inputSchema: {
-            projectPath: z
-                .string()
-                .describe('Absolute path to the project root containing planu/specs/'),
-            specId: z.string().describe('Spec ID to link the PR to (e.g. SPEC-042)'),
-            prUrl: z.url().describe('Full URL of the pull request'),
-            prNumber: z
-                .number()
-                .int()
-                .positive()
-                .optional()
-                .describe('Pull request number (integer, e.g. 123)'),
-            platform: z
-                .enum(['github', 'gitlab', 'linear', 'other'])
-                .optional()
-                .describe('Platform hosting the PR. Valid values: github, gitlab, linear, other. Default: github'),
-        },
-    }, safeLicensed('link_pr_to_spec', (args) => handleLinkPrToSpec(args)));
-    s.registerTool('list_spec_prs', {
-        description: 'Lists all pull requests linked to specs in the project. ' +
-            'Optionally filter by specId to show PRs for a specific spec.',
-        annotations: { title: 'List Spec PRs', readOnlyHint: true },
-        inputSchema: {
-            projectPath: z
-                .string()
-                .describe('Absolute path to the project root containing planu/specs/'),
-            specId: z
-                .string()
-                .optional()
-                .describe('Spec ID to filter by (e.g. SPEC-042). If omitted, lists all linked PRs.'),
-        },
-    }, safeLicensed('list_spec_prs', (args) => handleListSpecPrs(args)));
-    // ── E2E Test Generator ──────────────────────────────────────────────────────
-    s.registerTool('generate_e2e_tests', {
-        description: 'Generates E2E test scaffolding from spec acceptance criteria. ' +
-            'Supports gherkin (BDD feature files), playwright (TypeScript), ' +
-            'testRigor (plain English), and plain (numbered list) formats. ' +
-            'Writes the output file to tests/e2e/ by default.',
-        annotations: { title: 'Generate E2E Tests' },
-        inputSchema: {
-            specId: z.string().describe('Spec ID to generate tests for (e.g. SPEC-042)'),
-            projectPath: z
-                .string()
-                .describe('Absolute path to the project root containing planu/specs/'),
-            framework: z
-                .enum(['gherkin', 'playwright', 'testRigor', 'plain'])
-                .optional()
-                .describe('Test framework to generate for. Valid values: gherkin (BDD feature files, default), playwright (TypeScript), testRigor (plain English steps), plain (numbered list)'),
-            outputPath: z
-                .string()
-                .optional()
-                .describe('Output file path (absolute or relative to projectPath). Defaults to tests/e2e/SPEC-XXX-{slug}.{ext}'),
-        },
-    }, safeLicensed('generate_e2e_tests', (args) => handleGenerateE2eTests(args)));
-    s.registerTool('e2e_test_status', {
-        description: 'Lists existing E2E test files in tests/e2e/ that match the SPEC-XXX naming pattern. ' +
-            'Shows which specs already have E2E test coverage and which framework was used.',
-        annotations: { title: 'E2E Test Status', readOnlyHint: true },
-        inputSchema: {
-            projectPath: z.string().describe('Absolute path to the project root'),
-        },
-    }, safeLicensed('e2e_test_status', (args) => handleE2eTestStatus(args)));
-    // ── API Spec Generator ──────────────────────────────────────────────────────
-    s.registerTool('generate_spec_from_api', {
-        description: 'Generate Planu specs from an existing API contract. ' +
-            'Accepts OpenAPI 3.x / Swagger 2.0 JSON or GraphQL SDL and creates structured specs with ' +
-            'acceptance criteria derived from required fields, response codes, and field formats. ' +
-            'Useful for reverse-engineering specs from documented APIs.',
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root'),
-            content: z
-                .string()
-                .min(2)
-                .max(200000)
-                .optional()
-                .describe('Raw content of the API contract. For OpenAPI: JSON string. For GraphQL: SDL string.'),
-            filePath: z
-                .string()
-                .min(1)
-                .max(4096)
-                .optional()
-                .describe('Absolute path to the API contract file (.json for OpenAPI, .graphql/.gql/.sdl for GraphQL). ' +
-                'Provide either content or filePath.'),
-            mode: z
-                .enum(['by-endpoint', 'by-resource', 'by-operation'])
-                .describe('How to group API operations into specs. ' +
-                'by-endpoint: one spec per REST endpoint (POST /users → spec "Create User"). ' +
-                'by-resource: one spec per resource grouping all CRUD ops (User → spec with all operations). ' +
-                'by-operation: one spec per GraphQL query/mutation/subscription.'),
-            extraTags: z
-                .array(z.string().max(50))
-                .max(10)
-                .optional()
-                .describe("Additional tags to attach to all generated specs, e.g. ['payments', 'v2']"),
-        },
-        annotations: {
-            title: 'Generate Specs from API Contract',
-            readOnlyHint: false,
-            destructiveHint: false,
-        },
-    }, safeTracked('generate_spec_from_api', async (args) => handleGenerateSpecFromApi(args)));
-    // ── Generate Spec From Design ───────────────────────────────────────────────
-    s.registerTool('generate_spec_from_design', {
-        description: 'Generate a Planu spec from a UI/UX design description. Accepts screen descriptions, user flows, and component lists to produce a structured spec with acceptance criteria derived from the design intent.',
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root'),
-            title: z.string().min(3).max(200).describe("Feature title, e.g. 'User Profile Screen'"),
-            designDescription: z
-                .string()
-                .min(10)
-                .max(5000)
-                .describe('Full description of the design: what the user sees, what they can do, visual structure'),
-            screens: z
-                .array(z.string().max(500))
-                .max(20)
-                .optional()
-                .describe('List of screen names or descriptions included in this design'),
-            userFlows: z
-                .array(z.string().max(500))
-                .max(20)
-                .optional()
-                .describe("User flows, e.g. 'User taps Save → shows success toast → returns to list'"),
-            components: z
-                .array(z.string().max(200))
-                .max(30)
-                .optional()
-                .describe('UI components involved: buttons, forms, modals, etc.'),
-            type: z
-                .enum(['feature', 'bugfix', 'refactor'])
-                .optional()
-                .default('feature')
-                .describe('Spec type: feature, bugfix, or refactor'),
-            tags: z
-                .array(z.string().max(50))
-                .max(10)
-                .optional()
-                .describe("Tags for the spec, e.g. ['frontend', 'mobile', 'ux']"),
-        },
-        annotations: { readOnlyHint: false, destructiveHint: false },
-    }, safeTracked('generate_spec_from_design', async (args) => handleGenerateSpecFromDesign(args)));
-    // ── Living Spec ─────────────────────────────────────────────────────────────
-    s.registerTool('validate_annotations', {
-        description: 'Validate @spec annotations in source code. Checks that all annotated spec IDs exist and criteria numbers are valid. Use after adding annotations to verify correctness.',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            ...projectIdSchema,
-            specId: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Optional spec ID to filter annotations for a specific spec'),
-        },
-    }, safeLicensed('validate_annotations', withProject((args) => handleValidateAnnotations(args))));
-    s.registerTool('generate_annotations', {
-        description: 'Suggest @spec annotations for unannotated source files. Uses living-spec-analyzer heuristics to match files to spec criteria and generates annotation comments to add.',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            ...projectIdSchema,
-            specId: z.string().min(1).max(500).describe('Spec ID to generate annotations for'),
-        },
-    }, safeLicensed('generate_annotations', withProject((args) => handleGenerateAnnotations(args))));
-    s.registerTool('snapshot_spec_hashes', {
-        description: 'Create or update a SHA-256 hash snapshot for a spec. Tracks file hashes and exported function signatures of all files referenced in the ## Technical section of spec.md (File Plan). Used for drift detection.',
-        inputSchema: {
-            ...projectIdSchema,
-            specId: z.string().min(1).max(500).describe('Spec ID to snapshot'),
-        },
-    }, safeLicensed('snapshot_spec_hashes', withProject((args) => handleSnapshotSpecHashes(args))));
-    s.registerTool('auto_reconcile', {
-        description: 'Auto-reconcile specs after code changes. Applies safe changes automatically (completion %, status flip, hash update, timestamp). Unsafe changes (status downgrade, criterion removal) are skipped and require manual approval. Rate-limited: max 1 per spec per 5 minutes.',
-        inputSchema: {
-            ...projectIdSchema,
-            specId: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Specific spec ID to reconcile (if omitted, finds affected specs from changedFiles)'),
-            changedFiles: z
-                .array(z.string().max(4096))
-                .max(1000)
-                .optional()
-                .describe('List of changed file paths to find affected specs'),
-        },
-    }, safeLicensed('auto_reconcile', withProject((args) => handleAutoReconcile(args))));
-    // ── Living Spec Advanced ────────────────────────────────────────────────────
-    s.registerTool('living_spec_watch', {
-        description: 'Start, stop, or check status of the in-memory drift watcher for a project. The watcher caches drift detection results with a configurable TTL to avoid redundant computations.',
-        inputSchema: {
-            ...projectIdSchema,
-            action: z
-                .enum(['start', 'stop', 'status'])
-                .describe('Action to perform. Valid values: "start", "stop", "status"'),
-            ttlSeconds: z
-                .number()
-                .int()
-                .min(5)
-                .max(3600)
-                .optional()
-                .describe('Cache TTL in seconds (5-3600). Default: 60. Only used with "start" action'),
-            excludePatterns: z
-                .array(z.string().max(500))
-                .max(50)
-                .optional()
-                .describe('Glob patterns to exclude from drift watching (e.g., ["node_modules/**", "dist/**"])'),
-        },
-    }, safeLicensed('living_spec_watch', withProject((args) => handleLivingSpecWatch(args))));
-    s.registerTool('living_spec_status', {
-        description: 'Get detailed status of the living spec watcher including cache state and configuration. Read-only diagnostic tool.',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            ...projectIdSchema,
-            specId: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Optional spec ID to get cached drift data for'),
-        },
-    }, safeLicensed('living_spec_status', withProject((args) => handleLivingSpecStatus(args))));
-    s.registerTool('spec_diff', {
-        description: 'Compare spec hash snapshots to detect file and signature changes. Shows a Markdown-formatted diff table. Use after snapshot_spec_hashes to see what changed.',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            ...projectIdSchema,
-            specId: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Specific spec ID to diff (if omitted, diffs all specs)'),
-        },
-    }, safeLicensed('spec_diff', withProject((args) => handleSpecDiff(args))));
-    s.registerTool('living_spec_coverage', {
-        description: 'Correlate test coverage with spec acceptance criteria. Parses Vitest JSON or JUnit XML reports and groups results by @spec annotations to determine criterion status (verified/regression/untested).',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            ...projectIdSchema,
-            coverageJsonPath: z
-                .string()
-                .max(4096)
-                .optional()
-                .describe('Path to Vitest JSON report file'),
-            junitXmlPath: z.string().max(4096).optional().describe('Path to JUnit XML report file'),
-        },
-    }, safeLicensed('living_spec_coverage', withProject((args) => handleLivingSpecCoverage(args))));
-    s.registerTool('sync_spec_to_code', {
-        description: 'Sync from spec to code: generate TODO comments for pending acceptance criteria that lack @spec annotations. Also detects conflicts between spec and code state.',
-        inputSchema: {
-            ...projectIdSchema,
-            specId: z.string().min(1).max(500).describe('Spec ID to sync from'),
-        },
-    }, safeLicensed('sync_spec_to_code', withProject((args) => handleSyncSpecToCode(args))));
-    s.registerTool('sync_code_to_spec', {
-        description: 'Sync from code to spec: detect @spec annotations in source code and generate progress updates for the corresponding spec criteria. Also detects conflicts.',
-        inputSchema: {
-            ...projectIdSchema,
-            specId: z.string().min(1).max(500).describe('Spec ID to sync to'),
-        },
-    }, safeLicensed('sync_code_to_spec', withProject((args) => handleSyncCodeToSpec(args))));
-    s.registerTool('resolve_sync_conflict', {
-        description: 'Resolve a sync conflict detected by sync_spec_to_code or sync_code_to_spec. Choose to accept the code state, accept the spec state, or provide a manual resolution.',
-        inputSchema: {
-            ...projectIdSchema,
-            conflictId: z.string().max(100).describe('Conflict ID from the sync result'),
-            resolution: z
-                .enum(['accept-code', 'accept-spec', 'manual'])
-                .describe('Resolution strategy. Valid values: "accept-code", "accept-spec", "manual"'),
-            manualResolution: z
-                .string()
-                .max(2000)
-                .optional()
-                .describe('Description of manual resolution (required when resolution is "manual")'),
-        },
-    }, safeLicensed('resolve_sync_conflict', withProject((args) => handleResolveSyncConflict(args))));
-}
-//# sourceMappingURL=group-integrations.js.map